34var maskLength = (byte)Math.Ceiling(Math.Log(httpMethods.Length, 2)); 58int knownMethodsArrayLength = (int)(Math.Pow(2, maskLength) + 1); 218var mask2 = (ulong)(Math.Pow(2, bitsCount) - 1);

191var maskSizeInBIts = Math.Log(mask, 2); 192var hexMaskSize = Math.Ceiling(maskSizeInBIts / 4.0); 210var maskSizeInBIts = Math.Log(mask, 2); 211var hexMaskSize = (byte)Math.Ceiling(maskSizeInBIts / 4);

61var equalColumnLengths = Math.Max((Console.WindowWidth / _columns.Count) - EXCESS_LENGTH_CREATED_BY_BORDERS, 5);

83int headCount = Math.Min(_buffer.Length - _removeIndex, _count);

420int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 458int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 580_stringOctets = new byte[Math.Max(length, Math.Min(_stringOctets.Length * 2, _maxHeadersLength))]; 629dst = new byte[Math.Max(stringLength, Math.Min(dst.Length * 2, _maxHeadersLength))];

145var writable = Math.Min(source.Length, _span.Length);

135var count = (int)Math.Min(readableBuffer.Length, destination.Length);

25return Math.Min(4096, pool.MaxBufferSize);

83int headCount = Math.Min(_buffer.Length - _removeIndex, _count);

420int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 458int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 580_stringOctets = new byte[Math.Max(length, Math.Min(_stringOctets.Length * 2, _maxHeadersLength))]; 629dst = new byte[Math.Max(stringLength, Math.Min(dst.Length * 2, _maxHeadersLength))];

145var writable = Math.Min(source.Length, _span.Length);

135var count = (int)Math.Min(readableBuffer.Length, destination.Length);

25return Math.Min(4096, pool.MaxBufferSize);

83int headCount = Math.Min(_buffer.Length - _removeIndex, _count);

420int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 458int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 580_stringOctets = new byte[Math.Max(length, Math.Min(_stringOctets.Length * 2, _maxHeadersLength))]; 629dst = new byte[Math.Max(stringLength, Math.Min(dst.Length * 2, _maxHeadersLength))];

145var writable = Math.Min(source.Length, _span.Length);

135var count = (int)Math.Min(readableBuffer.Length, destination.Length);

25return Math.Min(4096, pool.MaxBufferSize);

83int headCount = Math.Min(_buffer.Length - _removeIndex, _count);

420int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 458int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 580_stringOctets = new byte[Math.Max(length, Math.Min(_stringOctets.Length * 2, _maxHeadersLength))]; 629dst = new byte[Math.Max(stringLength, Math.Min(dst.Length * 2, _maxHeadersLength))];

145var writable = Math.Min(source.Length, _span.Length);

135var count = (int)Math.Min(readableBuffer.Length, destination.Length);

25return Math.Min(4096, pool.MaxBufferSize);

83int headCount = Math.Min(_buffer.Length - _removeIndex, _count);

420int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 458int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 580_stringOctets = new byte[Math.Max(length, Math.Min(_stringOctets.Length * 2, _maxHeadersLength))]; 629dst = new byte[Math.Max(stringLength, Math.Min(dst.Length * 2, _maxHeadersLength))];

145var writable = Math.Min(source.Length, _span.Length);

135var count = (int)Math.Min(readableBuffer.Length, destination.Length);

25return Math.Min(4096, pool.MaxBufferSize);

145var writable = Math.Min(source.Length, _span.Length);

135var count = (int)Math.Min(readableBuffer.Length, destination.Length);

25return Math.Min(4096, pool.MaxBufferSize);

83int headCount = Math.Min(_buffer.Length - _removeIndex, _count);

420int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 458int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 580_stringOctets = new byte[Math.Max(length, Math.Min(_stringOctets.Length * 2, _maxHeadersLength))]; 629dst = new byte[Math.Max(stringLength, Math.Min(dst.Length * 2, _maxHeadersLength))];

145var writable = Math.Min(source.Length, _span.Length);

135var count = (int)Math.Min(readableBuffer.Length, destination.Length);

25return Math.Min(4096, pool.MaxBufferSize);

226int dependencyPhase = Math.Max(node.DependencyPhaseForDeferredStaticComputation, _currentDependencyPhase);

2301var mask = Math.Pow(2, lines.Length) - 1;

15return s.Substring(0, Math.Min(128, s.Length))

194Console.WriteLine($"Instance {i}: {Math.Round(cumulativeProblemTime.TotalHours, 2)} hours"); 198Console.WriteLine($"Total missing key score (lower is better) = {Math.Round(totalProblemTime.TotalHours, 2)} hours");

100await context.Response.WriteAsync($"<tr><th>{SR["Big number (invariant):"]}</th><td>{(Math.Pow(2, 42) + 0.42).ToString("N", CultureInfo.InvariantCulture)}</td></tr>"); 101await context.Response.WriteAsync($"<tr><th>{SR["Big number (request):"]}</th><td>{(Math.Pow(2, 42) + 0.42).ToString("N", CultureInfo.CurrentCulture)}</td></tr>"); 102await context.Response.WriteAsync($"<tr><th>{SR["Big number negative (invariant):"]}</th><td>{(-Math.Pow(2, 42) + 0.42).ToString("N", CultureInfo.InvariantCulture)}</td></tr>"); 103await context.Response.WriteAsync($"<tr><th>{SR["Big number negative (request):"]}</th><td>{(-Math.Pow(2, 42) + 0.42).ToString("N", CultureInfo.CurrentCulture)}</td></tr>");

57(Math.Pow(DelayBase, i) + DelayConstant) * randomFactor);

211int max = Math.Max(lengthA, lengthB); 263d[i, j] = Math.Min(Math.Min(m1, m2), m3);

102start = Math.Min(token.VirtualChars[0].Span.Start, start); 103end = Math.Max(token.VirtualChars.Last().Span.End, end);

191var cookieChunkCount = (int)Math.Ceiling(value.Length * 1.0 / dataSizePerCookie); 206var length = Math.Min(dataSizePerCookie, remainingLength);

432message.MaxAge = Convert.ToInt64(Math.Floor((maxAge.Value).TotalSeconds))

90var candidateCapacity = Math.Max(_items.Length * 2, _minCapacity); 179var newCapacity = Math.Max(desiredCapacity, _minCapacity);

71precedence += decimal.Divide(digit, (decimal)Math.Pow(10, i)); 127precedence += decimal.Divide(digit, (decimal)Math.Pow(10, i));

59var sizeToRent = _currentBuffer.Length + Math.Max(MinimumRentedArraySize, remainingLength * 2); 80var sizeToRent = Math.Max(MinimumRentedArraySize, remainingLength * 2);

340count = Math.Min(request.Count, Pagination.ItemsPerPage - request.StartIndex);

223sizeHint = Math.Max(this.MinimumSpanLength, sizeHint);

49(int)Math.Min(signalRMaximumIncomingBytes, 50 * 1024) - 512 :

148_byteArraysToBeRevivedTotalBytes += Math.Max(4, data.Length);

90var candidateCapacity = Math.Max(_items.Length * 2, _minCapacity); 179var newCapacity = Math.Max(desiredCapacity, _minCapacity);

157var growBy = Math.Max(sizeHint, _rentedBuffer.Length);

36var lengthPrefixBuffer = buffer.Slice(0, Math.Min(MaxLengthPrefixSize, buffer.Length));

187_currentSegment = ArrayPool<byte>.Shared.Rent(Math.Max(_minimumSegmentSize, sizeHint));

239var writable = Math.Min(bytesLeftToCopy, _span.Length);

1109int bytesRead = Math.Min(remainingByteLength, this.reader.UnreadSpan.Length);

484int toCopy = Math.Min(nextSpan.Length, destination.Length - copied);

73var maxBytesToRead = (int)Math.Min(bytesAvailableToRead, buffer.Length);

59var sizeToRent = _currentBuffer.Length + Math.Max(MinimumRentedArraySize, remainingLength * 2); 80var sizeToRent = Math.Max(MinimumRentedArraySize, remainingLength * 2);

210var lastItemIndex = Math.Min(_itemsBefore + _visibleItemCapacity, _itemCount); 212var placeholdersBeforeCount = Math.Min(_loadedItemsStartIndex, lastItemIndex); 252_lastRenderedPlaceholderCount = Math.Max(0, lastItemIndex - _itemsBefore - _lastRenderedItemCount); 264var itemsAfter = Math.Max(0, _itemCount - _visibleItemCapacity - _itemsBefore); 296var itemsBefore = Math.Max(0, _itemCount - itemsAfter - visibleItemCapacity); 329itemsInSpacer = Math.Max(0, (int)Math.Floor(spacerSize / _itemSize) - OverscanCount); 330visibleItemCapacity = (int)Math.Ceiling(containerSize / _itemSize) + 2 * OverscanCount; 339itemsBefore = Math.Max(0, _itemCount - visibleItemCapacity);

95numBytesToRead = (int)Math.Min(numBytesToRead, _totalLength - _offset);

90var candidateCapacity = Math.Max(_items.Length * 2, _minCapacity); 179var newCapacity = Math.Max(desiredCapacity, _minCapacity);

95numBytesToRead = (int)Math.Min(numBytesToRead, _totalLength - _offset);

191var cookieChunkCount = (int)Math.Ceiling(value.Length * 1.0 / dataSizePerCookie); 206var length = Math.Min(dataSizePerCookie, remainingLength);

58int numBytesToCopy = Math.Min(numBytesRemaining, T_blockIndex.Length);

47var numBytesToCopyThisIteration = Math.Min(prfOutputSizeInBytes, outputCount);

67uint numBytesToCopy = Math.Min(cbDerivedKey, SHA512_DIGEST_SIZE_IN_BYTES);

128new Version(Math.Max(0, current.Major - 1), 0, 0, 0),

149var preErrorLineNumberInFile = Math.Max(errorStartLineNumberInFile - _sourceCodeLineCount, 1);

229AppendNanoseconds(builder, Math.Abs(nanos));

229AppendNanoseconds(builder, Math.Abs(nanos));

149var preErrorLineNumberInFile = Math.Max(errorStartLineNumberInFile - _sourceCodeLineCount, 1);

95var toRead = Math.Min(count, _length - _position); 108var toRead = (int)Math.Min(buffer.Length, _length - _position);

57readLength = (int)Math.Min(bytesRemaining.GetValueOrDefault(), (long)readLength);

680capacity = Math.Max(DefaultCapacity, Math.Max(storage.Properties.Length, capacity));

78int nextCapacity = Math.Max(_span.Length != 0 ? _span.Length * 2 : 4, _span.Length + additionalCapacityRequired); 88nextCapacity = Math.Max(Math.Max(_span.Length + 1, ArrayMaxLength), _span.Length);

187_currentSegment = ArrayPool<byte>.Shared.Rent(Math.Max(_minimumSegmentSize, sizeHint));

155length = Math.Min(buffer.Count - buffer.Offset, _internalBuffer.Buffer.Length);

57readLength = (int)Math.Min(bytesRemaining.GetValueOrDefault(), (long)readLength);

78int nextCapacity = Math.Max(_span.Length != 0 ? _span.Length * 2 : 4, _span.Length + additionalCapacityRequired); 88nextCapacity = Math.Max(Math.Max(_span.Length + 1, ArrayMaxLength), _span.Length);

293char[] poolArray = ArrayPool<char>.Shared.Rent((int)Math.Max((uint)(_pos + additionalCapacityBeyondPos), (uint)_chars.Length * 2));

57readLength = (int)Math.Min(bytesRemaining.GetValueOrDefault(), (long)readLength);

121var bytes = Math.Min(end.Value, length);

620var toWrite = Math.Min(size - written, bytes.Length);

184sizeHint = Math.Max(MinimumBufferSize, sizeHint); 186var adjustedToMaximumSize = Math.Min(maxBufferSize, sizeHint);

94var innerCount = Math.Min(remaining, span.Length);

85var innerCount = Math.Min(remaining, span.Length);

78int nextCapacity = Math.Max(_span.Length != 0 ? _span.Length * 2 : 4, _span.Length + additionalCapacityRequired); 88nextCapacity = Math.Max(Math.Max(_span.Length + 1, ArrayMaxLength), _span.Length);

293char[] poolArray = ArrayPool<char>.Shared.Rent((int)Math.Max((uint)(_pos + additionalCapacityBeyondPos), (uint)_chars.Length * 2));

133entryCount = Math.Max(forwardedFor.Length, entryCount); 145entryCount = Math.Max(forwardedProto.Length, entryCount); 159entryCount = Math.Max(forwardedHost.Length, entryCount); 174entryCount = Math.Max(forwardedPrefix.Length, entryCount);

40var maxAge = Convert.ToInt64(Math.Floor(hstsOptions.MaxAge.TotalSeconds))

96var bits = Math.Min(5 - bitIndex, 8 - outputBits);

80var numAttempts = Math.Max(1, retryAttribute.MaxRetries);

191var cookieChunkCount = (int)Math.Ceiling(value.Length * 1.0 / dataSizePerCookie); 206var length = Math.Min(dataSizePerCookie, remainingLength);

121var bytes = Math.Min(end.Value, length);

66count = Math.Max(count, 1); 72count = Math.Max(count, 1);

264var pageLength = Math.Min(length, page.Length);

202var compareLength = Math.Max(xLength, yLength); 245var length = Math.Max(xSegment.Length, ySegment.Length);

58segment = _viewBufferPool.Rent(Math.Max(pageSize, MinimumSize));

57var pageLength = Math.Min(length, page.Length);

60var copyLength = Math.Min(count, page.Length - _charIndex); 81var copyLength = Math.Min(count, page.Length - _charIndex);

157var growBy = Math.Max(sizeHint, _rentedBuffer.Length);

281Assert.Equal(Math.Min(ModelWithMaxLengthMetadata.MaxLengthAttributeValue, ModelWithMaxLengthMetadata.StringLengthAttributeValue), int.Parse(attribute.Value, CultureInfo.InvariantCulture));

345var expectedWriteCallCount = Math.Ceiling((double)writeLength / TestHttpResponseStreamWriterFactory.DefaultBufferSize);

187_currentSegment = ArrayPool<byte>.Shared.Rent(Math.Max(_minimumSegmentSize, sizeHint));

200var toWrite = Math.Min(value.Length, available.Length);

94int growBy = Math.Max(sizeHint, currentLength); 98growBy = Math.Max(growBy, DefaultInitialBufferSize);

100var toWrite = Math.Min(buffer.Length, available.Length);

83var bytes = Math.Min(rand.Next(4, 1024), value.Length); 96var bytes = Math.Min(rand.Next(4, 1024), value.Length); 98bytes = Math.Min(bytes, span.Length); 111var bytes = Math.Min(rand.Next(4, 1024), value.Length);

144var bytesWritten = Math.Min(buffer.Length, _segmentSize - (int)_bufferStream.Length);

155nextCapacity = Math.Max(capacity + 1, MaxCoreClrArrayLength); 158nextCapacity = Math.Max(nextCapacity, minimum);

84maxDepth = Math.Max(maxDepth, endpoint.RoutePattern.PathSegments.Count); 560maxSegmentCount = Math.Max(maxSegmentCount, node.PathDepth);

161bestMatchIndex = Math.Max(bestMatchIndex, 0);

50precedence += decimal.Divide(digit, (decimal)Math.Pow(10, i)); 71precedence += decimal.Divide(digit, (decimal)Math.Pow(10, i)); 104precedence += decimal.Divide(digit, (decimal)Math.Pow(10, i)); 127precedence += decimal.Divide(digit, (decimal)Math.Pow(10, i));

156var text = guid.Substring(0, Math.Max(5, Math.Min(i, 36)));

317cachePolicy.SecondsToLive = (uint)Math.Min(_cacheTtl.Value.Ticks / TimeSpan.TicksPerSecond, Int32.MaxValue);

83int headCount = Math.Min(_buffer.Length - _removeIndex, _count);

420int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 458int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 580_stringOctets = new byte[Math.Max(length, Math.Min(_stringOctets.Length * 2, _maxHeadersLength))]; 629dst = new byte[Math.Max(stringLength, Math.Min(dst.Length * 2, _maxHeadersLength))];

145var writable = Math.Min(source.Length, _span.Length);

135var count = (int)Math.Min(readableBuffer.Length, destination.Length);

25return Math.Min(4096, pool.MaxBufferSize);

36var actual = Math.Min(readableBuffer.Length, memory.Length);

145var writable = Math.Min(source.Length, _span.Length);

135var count = (int)Math.Min(readableBuffer.Length, destination.Length);

25return Math.Min(4096, pool.MaxBufferSize);

149var preErrorLineNumberInFile = Math.Max(errorStartLineNumberInFile - _sourceCodeLineCount, 1);

400var actual = Math.Min(buffer.Length, _inputLength);

133var actual = (int)Math.Min(length, destination.Length);

170StreamPool = new PooledStreamStack<Http2Stream>(Math.Min(InitialStreamPoolSize, http2Limits.MaxStreamsPerConnection)); 180(int)Math.Min(MaxTrackedStreams, int.MaxValue), 203internal uint MaxTrackedStreams => Math.Max(_serverSettings.MaxConcurrentStreams * 2, 100); 941_frameWriter.UpdateMaxFrameSize(Math.Min(_clientSettings.MaxFrameSize, _serverSettings.MaxFrameSize)); 968_frameWriter.UpdateMaxHeaderTableSize(Math.Min(_clientSettings.HeaderTableSize, (uint)Limits.Http2.HeaderTableSize)); 1775var copyAmount = (int)Math.Min(outputBuffer.Length, readResult.Buffer.Length);

949return Math.Min(bytes, _connectionWindow);

164return Math.Min(bytes, _streamWindow);

165for (var i = 0; i < Math.Min(span.Length, maxChars); i++)

387sizeHint = Math.Max(MinimumBufferSize, sizeHint); 389var adjustedToMaximumSize = Math.Min(maxBufferSize, sizeHint);

114_readTimingElapsedTicks += Math.Min(timestamp - _lastTimestamp, _heartbeatIntervalTicks); 296var singleWriteTimeoutTimestamp = currentTimeUpperBound + Math.Max( 309_writeTimingTimeoutTimestamp = Math.Max(singleWriteTimeoutTimestamp, accumulatedWriteTimeoutTimestamp); 343return Math.Max(_writeTimingTimeoutTimestamp, gracePeriod);

83int headCount = Math.Min(_buffer.Length - _removeIndex, _count);

420int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 458int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 580_stringOctets = new byte[Math.Max(length, Math.Min(_stringOctets.Length * 2, _maxHeadersLength))]; 629dst = new byte[Math.Max(stringLength, Math.Min(dst.Length * 2, _maxHeadersLength))];

287int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 373int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex);

145var writable = Math.Min(source.Length, _span.Length);

135var count = (int)Math.Min(readableBuffer.Length, destination.Length);

25return Math.Min(4096, pool.MaxBufferSize);

100Assert.Equal(Math.Min(dirCount, fileCount), watcher.TestGetDirectoryWatchCountUnsynchronized());

87var roundedActualMs = Math.Round(actualMs / 50.0) * 50.0;

1092var delay = (int)Math.Ceiling(timeout.TotalMilliseconds / MaxWaitLoop);

15return s.Substring(0, Math.Min(128, s.Length))

172int expectedCount = Math.Min(finalMaxSize / 64, headers.Count);

343int resolvedSize = Math.Min(encoded.Length - i, chunkSize);

20private static readonly int IOQueueCount = Math.Min(Environment.ProcessorCount, 16);

20public int ListenerQueueCount { get; set; } = Math.Min(Environment.ProcessorCount, 16);

38public int IOQueueCount { get; set; } = Math.Min(Environment.ProcessorCount, 16);

33public int IOQueueCount { get; set; } = Math.Min(Environment.ProcessorCount, 16);

172int expectedCount = Math.Min(finalMaxSize / 64, headers.Count);

343int resolvedSize = Math.Min(encoded.Length - i, chunkSize);

60var expectedSegmentSize = Math.Min(segmentSize, WriteData.Length - i); 84stream.Write(WriteData, i, Math.Min(writeSize, WriteData.Length - i)); 93var expectedSegmentSize = Math.Min(segmentSize, WriteData.Length - i);

83int headCount = Math.Min(_buffer.Length - _removeIndex, _count);

420int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 458int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 580_stringOctets = new byte[Math.Max(length, Math.Min(_stringOctets.Length * 2, _maxHeadersLength))]; 629dst = new byte[Math.Max(stringLength, Math.Min(dst.Length * 2, _maxHeadersLength))];

287int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 373int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex);

144var bytesWritten = Math.Min(buffer.Length, _segmentSize - (int)_bufferStream.Length);

145var writable = Math.Min(source.Length, _span.Length);

135var count = (int)Math.Min(readableBuffer.Length, destination.Length);

25return Math.Min(4096, pool.MaxBufferSize);

373var numElements = (int)Math.Min(BufferLength, Math.Max(1, sequenceId - (linkedBuffer._startingSequenceId - 1)));

187_currentSegment = ArrayPool<byte>.Shared.Rent(Math.Max(_minimumSegmentSize, sizeHint));

187_currentSegment = ArrayPool<byte>.Shared.Rent(Math.Max(_minimumSegmentSize, sizeHint));

36var lengthPrefixBuffer = buffer.Slice(0, Math.Min(MaxLengthPrefixSize, buffer.Length));

373var numElements = (int)Math.Min(BufferLength, Math.Max(1, sequenceId - (linkedBuffer._startingSequenceId - 1)));

36var lengthPrefixBuffer = buffer.Slice(0, Math.Min(MaxLengthPrefixSize, buffer.Length));

36var lengthPrefixBuffer = buffer.Slice(0, Math.Min(MaxLengthPrefixSize, buffer.Length));

187_currentSegment = ArrayPool<byte>.Shared.Rent(Math.Max(_minimumSegmentSize, sizeHint));

187_currentSegment = ArrayPool<byte>.Shared.Rent(Math.Max(_minimumSegmentSize, sizeHint));

187_currentSegment = ArrayPool<byte>.Shared.Rent(Math.Max(_minimumSegmentSize, sizeHint));

187_currentSegment = ArrayPool<byte>.Shared.Rent(Math.Max(_minimumSegmentSize, sizeHint));

121var bytes = Math.Min(end.Value, length);

121var bytes = Math.Min(end.Value, length);

121var bytes = Math.Min(end.Value, length);

99var actual = Math.Min(readableBuffer.Length, buffer.Length);

141int count = Math.Min(buffer.Count, receiveMessage.Buffer.Count);

206parsedOptions.ServerMaxWindowBits = Math.Min(parsedServerMaxWindowBits ?? 15, serverMaxWindowBits);

78int nextCapacity = Math.Max(_span.Length != 0 ? _span.Length * 2 : 4, _span.Length + additionalCapacityRequired); 88nextCapacity = Math.Max(Math.Max(_span.Length + 1, ArrayMaxLength), _span.Length);

293char[] poolArray = ArrayPool<char>.Shared.Rent((int)Math.Max((uint)(_pos + additionalCapacityBeyondPos), (uint)_chars.Length * 2));

133int actualCount = Math.Min(count, _topBuffer.Count); 197var actualCount = Math.Min(count, _topBuffer.Count);

209int toCopy = Math.Min(_bufferCount, count); 231int toCopy = Math.Min(_bufferCount, buffer.Length);

284var rentedBuffer = _bytePool.Rent(Math.Min((int)oldBuffer.Length, _maxRentedBufferSize)); 359var rentedBuffer = _bytePool.Rent(Math.Min((int)oldBuffer.Length, _maxRentedBufferSize)); 432bufferSize = Math.Max(4096, bufferSize);

629var remaining = Math.Min(_charBufferSize - _charBufferCount, count); 644var remaining = Math.Min(_charBufferSize - _charBufferCount, count); 660var remaining = Math.Min(_charBufferSize - _charBufferCount, value.Length);

177var slice = buffer.AsSpan(0, Math.Min(buffer.Length, index)); 197read = _innerStream.Read(buffer, offset, Math.Min(count, matchOffset - bufferedData.Offset)); 208read = _innerStream.Read(buffer, offset, Math.Min(count, bufferedData.Count)); 257var slice = buffer[..Math.Min(buffer.Length, index)]; 280var slice = buffer[..Math.Min(buffer.Length, matchOffset - bufferedData.Offset)]; 294read = _innerStream.Read(buffer.Span[..Math.Min(buffer.Length, bufferedData.Count)]); 325matchOffset = Math.Max(segment1.Offset, segment1.Offset + segment1.Count - matchBytes.Length); 352bufferSize = Math.Max(4096, bufferSize); 361bufferSize = Math.Max(4096, bufferSize);

53var copyLength = Math.Min(memory.Length, currentPage.Length - _currentPageIndex);

133var expectedWriteCount = Math.Ceiling((double)byteLength / HttpResponseStreamWriter.DefaultBufferSize); 171var expectedWriteCount = Math.Ceiling((double)byteLength / HttpResponseStreamWriter.DefaultBufferSize);

59count = Math.Max(count, 1); 65count = Math.Max(count, 1);

1952Math.Round(projectGraph.ConstructionMetrics.ConstructionTime.TotalSeconds, 3),

623NodeProviderOutOfProcBase.ConnectToPipeStream(_nodeStream, _pipeName, _handshake, Math.Max(1, timeoutMilliseconds - (int)sw.ElapsedMilliseconds));

283remainingToRelease = Convert.ToInt32(Math.Max(1, Math.Floor(_configurations.Count * 0.1)));

778int lengthToWrite = Math.Min(writeStreamLength - i, MaxPacketWriteSize); 856delay = Math.Min(delay * 2, 500);

318_queueCapacity = Math.Max(0, _queueCapacity); 1788int newMinImportance = Math.Max((int)_minimumRequiredMessageImportance, (int)minimumImportance);

874coresBeingReleased = Math.Min(coresBeingReleased, _additionalAcquiredCores);

585int grantedCores = Math.Min(requestedCores, availableCores); 1303configurationCountLimit = Math.Max(1, (int)Math.Ceiling(configurationCountLimit * _customSchedulerForSQLConfigurationLimitMultiplier / _availableNodes.Count)); 1408int implicitlyGrantedCores = Math.Max(1, (_schedulingData.ExecutingRequestsCount * _nodeCoreAllocationWeight) / 100); 1413return Math.Max(0, _coreLimit - (implicitlyGrantedCores + explicitlyGrantedCores)); 1553inProcNodesToCreate = Math.Min(availableNodesWithInProcAffinity, inProcNodesToCreate); 1585outOfProcNodesToCreate = Math.Min(maxCreatableOutOfProcNodes, outOfProcNodesToCreate); 2502int postPad = Math.Max(20 /* field width */ - (2 * level) /* spacing for hierarchy lines */ - 3 /* length allocated for config/request id */, 0);

680coresToRemove = Math.Min(request.GrantedCores, coresToRemove);

418MaximumConfigurationId = Math.Max(MaximumConfigurationId, configId);

44int comparison = Math.Sign(h1.Count - h2.Count);

41int limit = (int)Math.Sqrt(candidate);

2978string displayValue = escapedValue.Substring(0, Math.Min(escapedValue.Length, 75)) + ((escapedValue.Length > 75) ? "..." : String.Empty); 2985string displayOriginalValue = originalValue.Substring(0, Math.Min(originalValue.Length, 75)) + ((originalValue.Length > 75) ? "..." : String.Empty);

3899else if (_receiverType == typeof(Math)) 3901if (string.Equals(_methodMethodName, nameof(Math.Max), StringComparison.OrdinalIgnoreCase)) 3905returnVal = Math.Max(arg0, arg1); 3909else if (string.Equals(_methodMethodName, nameof(Math.Min), StringComparison.OrdinalIgnoreCase)) 3913returnVal = Math.Min(arg0, arg1); 4643if (Math.Abs(arg - d) == 0) 4680if (Math.Abs(arg - d) == 0)

36return Math.Round(timeSpan.TotalMilliseconds, 0, MidpointRounding.AwayFromZero); 44return Math.Round(percentage, 1, MidpointRounding.AwayFromZero);

999dop = Math.Min(taskOptions.MaxTasksPerIteration, taskOptions.AvailableTasks); 2537int compareLength = Math.Min( 2576var maxTasks = Math.Max(1, NativeMethodsShared.GetLogicalCoreCount() / 2);

397var headingSegmentsToRemove = Math.Max(0, segments.Length - trailingSegmentsToKeep);

3059_importPaths = new List<string>(Math.Max(0, importClosure.Count - 1) /* outer project */); 3071_importPathsIncludingDuplicates = new List<string>(Math.Max(0, importClosureWithDuplicates.Count - 1) /* outer project */);

812"{0,5}", Math.Round(elapsedTime.TotalMilliseconds, 0));

48int read = stream.Read(buffer, 0, (int)Math.Min(bytesCount - totalRead, buffer.Length));

46count = Math.Min((int)Math.Max(Length - _position, 0), count);

53int prettyLength = System.Math.Min(11, rawTimeLength);

110int remainingCharsToEndOfBuffer = Math.Min(bufferWidthMinusNewLine - cursor, count - endIndex);

1756"{0,5}", Math.Round(elapsedTime.TotalMilliseconds, 0));

365int waitTimeRemaining = Math.Max(0, CommunicationsUtilities.NodeConnectionTimeout - (int)usedWaitTime.TotalMilliseconds);

353availableStaticMethods.TryAdd("System.Math", new Tuple<string, Type>(null, typeof(Math)));

62int length = Math.Min(span.Length, other.Length);

114return version.ToString(Math.Max(nonZeroVersionParts, minVersionPartCount));

44int comparison = Math.Sign(h1.Count - h2.Count);

747"{0,5}", Math.Round(elapsedTime.TotalMilliseconds, 0));

53int prettyLength = System.Math.Min(11, rawTimeLength);

1576"{0,5}", Math.Round(elapsedTime.TotalMilliseconds, 0));

211availableStaticMethods.TryAdd("System.Math", new Tuple<string, Type>(null, typeof(System.Math)));

397var headingSegmentsToRemove = Math.Max(0, segments.Length - trailingSegmentsToKeep);

129Assert.Equal(expectedSign, Math.Sign(version1.CompareTo(version2)));

49var limit = (int)Math.Sqrt(candidate);

488var currentSegmentLength = Math.Min(remainingInSegment, _length); 497var currentSegmentLength = Math.Min(SegmentedArrayHelper.GetSegmentSize<T>(), _length - _completed); 592var currentSegmentLength = Math.Min(Math.Min(remainingInFirstSegment, remainingInSecondSegment), _length - _completed); 640var currentSegmentLength = Math.Min(Math.Min(remainingInFirstSegment, remainingInSecondSegment), _length - _completed); 730_current = segment.AsMemory().Slice(offset, Math.Min(remainingInSegment, _length)); 737_current = segment.AsMemory().Slice(0, Math.Min(SegmentedArrayHelper.GetSegmentSize<T>(), _length - _completed)); 779_current = segment.AsMemory().Slice(offset, Math.Min(remainingInSegment, _length)); 786_current = segment.AsMemory().Slice(0, Math.Min(SegmentedArrayHelper.GetSegmentSize<T>(), _length - _completed));

24int randomBytesNeeded = (int)Math.Ceiling(length * bytesNumNeededForSingleStringChar);

999dop = Math.Min(taskOptions.MaxTasksPerIteration, taskOptions.AvailableTasks); 2537int compareLength = Math.Min( 2576var maxTasks = Math.Max(1, NativeMethodsShared.GetLogicalCoreCount() / 2);

397var headingSegmentsToRemove = Math.Max(0, segments.Length - trailingSegmentsToKeep);

736int maxCount = Math.Min(inputsToProcess.Count, outputsToProcess.Count); 737maxCount = Math.Min(maxCount, 5); // Limit to just 5

86int charsToProcess = Math.Min(itemSpec.Length - itemSpecPosition, MaxInputChunkLength);

388charactersExtracted = Math.Min(length - i, charactersOnPage - relativeStartPosition);

277for (int i = 0; i < Math.Pow(2, attrs.Length); i++) 282if ((i & (int)Math.Pow(2, k)) != 0)

264for (int i = 0; i < Math.Pow(2, attrs.Length); i++) 269if ((i & (int)Math.Pow(2, k)) != 0)

442for (int i = 0; i < Math.Pow(2, attrs.Length); i++) 447if ((i & (int)Math.Pow(2, k)) != 0)

288int minimumLength = Math.Min(expectedItems.Length, items.Count); 1936for (int i = 0; i < Math.Min(actualLines.Length, expectedLines.Length); i++)

999dop = Math.Min(taskOptions.MaxTasksPerIteration, taskOptions.AvailableTasks); 2537int compareLength = Math.Min( 2576var maxTasks = Math.Max(1, NativeMethodsShared.GetLogicalCoreCount() / 2);

397var headingSegmentsToRemove = Math.Max(0, segments.Length - trailingSegmentsToKeep);

79int minBytesAvailable = Math.Min(bytesLocalAvailable, bytesRemoteAvailable);

166Math.Pow(RetryDelayBase, i) + RetryDelayConstant);

99Math.Pow(RetryDelayBase, i) + RetryDelayConstant);

174var min = (int)(Math.Pow(factor, attempt) * 1000); 175var max = (int)(Math.Pow(factor, attempt + 1) * 1000);

211int max = Math.Max(lengthA, lengthB); 263d[i, j] = Math.Min(Math.Min(m1, m2), m3);

76var maxSize = Math.Min(maxItemsToHash, values.Length);

324int min = Math.Min(dir1.Length, dir2.Length);

97public string SimpleVersion => Commit?.Substring(0, Math.Min(7, Commit.Length)) ?? "latest";

163var growBy = Math.Max(sizeHint, currentLength); 167growBy = Math.Max(growBy, DefaultInitialBufferSize);

163var growBy = Math.Max(sizeHint, currentLength); 167growBy = Math.Max(growBy, DefaultInitialBufferSize);

573return (long)Math.Min(

118format.Substring(i * MaxChunkSize, Math.Min(MaxChunkSize, format.Length - i * MaxChunkSize)), i, chunkCount, 233descriptorString.Substring(i * MaxChunkSize, Math.Min(MaxChunkSize, descriptorString.Length - i * MaxChunkSize)), i, chunkCount);

367return (CallSiteResultCacheLocation)Math.Max((int)locationA, (int)locationB);

66long expectedLength = Math.Max(utf8Bom.Length, stream.Length - stream.Position) + 1;

169_byteBuffer = new byte[Math.Max(byteCount, 256)];

63var unixTimestamp = Convert.ToInt64(Math.Round((DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0)).TotalSeconds));

96var bits = Math.Min(5 - bitIndex, 8 - outputBits);

304int newCapacity = (int)Math.Max( 306Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

186sizeHint = Math.Max(sizeHint, MaximumBufferSize - currentLength); 191int growBy = Math.Max(sizeHint, currentLength);

861return Math.Abs((int)result);

180int nextCapacity = Math.Max(_span.Length != 0 ? _span.Length * 2 : 4, _span.Length + additionalCapacityRequired); 190nextCapacity = Math.Max(Math.Max(_span.Length + 1, ArrayMaxLength), _span.Length);

80return Math.Abs((int)result);

58int typesHash = Math.Abs((int)hash);

114(_, _) => Math.Min(idxPartial, idxRef)

278int numArgumentsToCopy = Math.Min(numArgumentsToInsert, typeArgumentsToSubstitute.Length - currentArityOffset);

51_maxIndirectionLevelDataProvided = Math.Max(_maxIndirectionLevelDataProvided, indirectionDepth); 81_maxIndirectionLevelUsed = Math.Max(indirectionDepth, _maxIndirectionLevelUsed);

90var candidateCapacity = Math.Max(_items.Length * 2, _minCapacity); 179var newCapacity = Math.Max(desiredCapacity, _minCapacity);

150firstPESection = Math.Min(firstPESection.Position, sectionHeader.PointerToRawData);

1543SourceIndex = Math.Max(SourceIndex, PatternGroups(PGIndex).MinSourceIndex + 1)

1164For ParmIndex = 0 To Math.Min(LastArgIndexToCheck, ParamArrayIndex) - 1 1313For ParmIndex = 0 To Math.Min(ArgCountUpperBound, Math.Max(LastNonSetValueIndex0, LastNonSetValueIndex1)) 1785For ParmIndex = 0 To Math.Max(LastArgNonSetValueIndex, LastParamNonSetValueIndex) 1858Dim ArrayUBound As Integer = Math.Max(vars.GetUpperBound(0), paramOrder.GetUpperBound(0))

113ElseIf System.String.CompareOrdinal("Exception from HRESULT: 0x", 0, Msg, 0, Math.Min(Msg.Length, 26)) = 0 Then

1300Dim BufferSize As Integer = Math.Max(MaxByteDetectedEncoding, DEFAULT_BUFFER_SIZE)

5Imports System.Math

526int allowedParallelism = DisableParallelAot ? 1 : Math.Min(_assembliesToCompile.Count, Environment.ProcessorCount);

156int allowedParallelism = Math.Max(Math.Min(bundledResources.Count, Environment.ProcessorCount), 1); 469: encodedHash.Substring(0, Math.Min(encodedHash.Length, maxEncodedHashLength));

77int allowedParallelism = DisableParallelStripping ? 1 : Math.Min(Assemblies.Length, Environment.ProcessorCount);

522timeout = Math.Max(timeout, 50);

397var headingSegmentsToRemove = Math.Max(0, segments.Length - trailingSegmentsToKeep);

365int waitTimeRemaining = Math.Max(0, CommunicationsUtilities.NodeConnectionTimeout - (int)usedWaitTime.TotalMilliseconds);

29Width = Math.Min(width, MaxColumn);

156ReadOnlySpan<char> truncatedText = text.Slice(0, Math.Min(text.Length, Width - 1));

1217int length = Math.Min(maxLength - indent.Length, text.Length - start);

440_budget = Math.Max(1, newBuckets.Length / newLocks.Length);

112int nextSize = tail._preservedForObservation != 0 ? InitialSegmentLength : Math.Min(tail.Capacity * 2, MaxSegmentLength);

365int waitTimeRemaining = Math.Max(0, CommunicationsUtilities.NodeConnectionTimeout - (int)usedWaitTime.TotalMilliseconds);

360[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Math))]

1049[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Math))]

205int build = Math.Min(ushort.MaxValue, (int)days.TotalDays);

442scaledInteger = Math.Floor( scaledValue ) ;

377_curIndex = Math.Min(_curIndex+8, _pathLength); // "Infinity" has 8 characters 387_curIndex = Math.Min(_curIndex+3, _pathLength); // "NaN" has 3 characters

371return Math.Abs((Int32)to - (Int32)from); 388return Math.Abs(to.ScA - from.ScA) 389+ Math.Abs(to.ScR - from.ScR) 390+ Math.Abs(to.ScG - from.ScG) 391+ Math.Abs(to.ScB - from.ScB); 399return (Double)Math.Abs(to - from); 404return Math.Abs(to - from); 409return Math.Abs(to - from); 414return Math.Abs(to - from); 419return Math.Abs(to - from); 441return Math.Abs((to - from).Length); 446return Math.Abs((to - from).Length); 466return Math.Sqrt((a * a) + (b * b)); 476return Math.Abs(to - from); 481return Math.Abs(((System.Windows.Vector)to - (System.Windows.Vector)from).Length); 498return Math.Abs((to - from).Length); 503return Math.Abs((to - from).Length);

742int minLength = Math.Min(aLength, bLength);

931int smaller = Math.Min(lastChar, firstChar); 932int larger = Math.Max(lastChar, firstChar);

510_cp = Math.Min(cp, _dcp);

108List<double> list = new List<double>(Math.Min(256, value.Length / EstimatedCharCountPerItem + 1)); 151List<ushort> list = new List<ushort>(Math.Min(256, value.Length / EstimatedCharCountPerItem + 1)); 192List<bool> list = new List<bool>(Math.Min(256, value.Length / EstimatedCharCountPerItem + 1)); 234List<Point> list = new List<Point>(Math.Min(256, value.Length / EstimatedCharCountPerItem + 1));

389bool accept = (Math.Abs(det) > Math.Abs(s) * DoubleUtil.DBL_EPSILON && 390Math.Abs(det) > Math.Abs(u) * DoubleUtil.DBL_EPSILON); 537nPoints = (int)(Math.Sqrt(rCurv / tolerance)) + 3;

473rMin = Math.Min(rMin, a); 474rMax = Math.Max(a, rMax); 502_dist = Math.Abs(rR) + Math.Abs(rB);

34_radius = Math.Max(_radii.Width, _radii.Height); 121double distance = Math.Sqrt(distanceSquared); 142rad *= Math.Sqrt(1 - rSinSquared); 143spine *= Math.Sqrt(rSinSquared); 622radius = Math.Abs(nearest.Y); 626radius = Math.Abs(nearest.X); 725double tmp = Math.Sqrt(B*B-4.0f * A * C); 732findex = Math.Min(s1, s2); 759findex = Math.Abs(Math.Min(s1, s2) - 0d) < Math.Abs(Math.Max(s1, s2) - 1d) ? 0d : 1d;

186Math.Min(lastFragment.BeginFIndex, fragment.BeginFIndex), 187Math.Max(lastFragment.EndFIndex, fragment.EndFIndex));

163uint ulAbsMaxDelDel = (uint)Math.Max(MathHelper.AbsNoThrow(minDelDel), MathHelper.AbsNoThrow(maxDelDel)); 165uint ulAbsMax = (uint)Math.Max(MathHelper.AbsNoThrow(minVal), MathHelper.AbsNoThrow(maxVal)); 236maxByte = Math.Max(input[n], maxByte); 237maxShort = Math.Max((ushort)shortReader.ReadUInt16Reverse(Native.BitsPerShort), maxShort); 247maxByte = Math.Max(input[n], maxByte); 248maxShort = Math.Max((ushort)shortReader.ReadUInt16Reverse(Native.BitsPerShort), maxShort); 254maxByte = Math.Max(input[n], maxByte); 296ulAbsMax = (uint)Math.Max(MathHelper.AbsNoThrow(minInt), MathHelper.AbsNoThrow(maxInt));

1408double dAngle = (tdrd.Transform[0] / 100) * (Math.PI / 180); 1410M00 = M11 = Math.Cos(dAngle); 1411M01 = Math.Sin(dAngle);

111ull = (ulong)Math.Abs(Value);

155DoubleUtil.GreaterThanOrClose(point.X, Math.Min(prevLassoPoint.X, lassoPoint.X)) && 156DoubleUtil.LessThanOrClose(point.X, Math.Max(prevLassoPoint.X, lassoPoint.X))) 165if (DoubleUtil.GreaterThanOrClose(point.X, Math.Max(prevLassoPoint.X, lassoPoint.X))) 170else if (DoubleUtil.GreaterThanOrClose(point.X, Math.Min(prevLassoPoint.X, lassoPoint.X))) 521return (Math.Abs(vector.X) < MinDistance && Math.Abs(vector.Y) < MinDistance);

569i = Math.Min(_visuals.Count, _strokes.Count); //not -1, we're about to decrement

782line1XMin = Math.Floor(line1Start.X); 783line1XMax = Math.Ceiling(line1End.X); 787line1XMin = Math.Floor(line1End.X); 788line1XMax = Math.Ceiling(line1Start.X); 793line2XMin = Math.Floor(line2Start.X); 794line2XMax = Math.Ceiling(line2End.X); 798line2XMin = Math.Floor(line2End.X); 799line2XMax = Math.Ceiling(line2Start.X); 804line1YMin = Math.Floor(line1Start.Y); 805line1YMax = Math.Ceiling(line1End.Y); 809line1YMin = Math.Floor(line1End.Y); 810line1YMax = Math.Ceiling(line1Start.Y); 815line2YMin = Math.Floor(line2Start.Y); 816line2YMax = Math.Ceiling(line2End.Y); 820line2YMin = Math.Floor(line2End.Y); 821line2YMax = Math.Ceiling(line2Start.Y); 1067double floor = Math.Floor(findex);

738double r = (Math.Abs(nextNode.X) < Math.Abs(nextNode.Y)) //DoubleUtil.IsZero(nextNode.X)

511return Math.Sqrt(nearestOnFirst.LengthSquared / shortest.LengthSquared);

93double delta = Math.Abs(GetAngleDeltaFromLast(strokeNode.PreviousPosition, strokeNode.Position, ref lastAngle)); 113if ((Math.Min(prevArea, currArea) / Math.Max(prevArea, currArea)) <= 0.70d) 254double maxExtent = Math.Max(drawingAttributes.Height, drawingAttributes.Width); 255percentIntersect += Math.Min(4.99999d, ((maxExtent / 20d) * 5d)); 523bool directionChangedOverAbsoluteThreshold = Math.Abs(delta) > 90d && Math.Abs(delta) < (360d - 90d); 524bool directionChangedOverOverlapThreshold = overlap && !(ignorePressure || strokeNode.PressureFactor == 1f) && Math.Abs(delta) > 30d && Math.Abs(delta) < (360d - 30d); 533if ((Math.Min(prevArea, currArea) / Math.Max(prevArea, currArea)) <= 0.90d) 838double intersectLeft = Math.Max(rect1.Left, rect2.Left); 839double intersectTop = Math.Max(rect1.Top, rect2.Top); 840double intersectWidth = Math.Max((double)(Math.Min(rect1.Right, rect2.Right) - intersectLeft), (double)0); 841double intersectHeight = Math.Max((double)(Math.Min(rect1.Bottom, rect2.Bottom) - intersectTop), (double)0); 851double minArea = Math.Min(rect1Area, rect2Area); 1054angle = Math.PI / 2.0; 1058angle = Math.PI * 3.0 / 2.0; 1069angle = Math.PI; 1076angle = Math.Atan(dy / dx) + Math.PI; 1080angle = Math.Atan(dy / dx) + (2 * Math.PI); 1084angle = Math.Atan(dy / dx); 1089angle = angle * 180 / Math.PI;

292int bytesToXor = (int) (Math.Min(ObfuscatedLength, unchecked (readPosition + (long) count)) - readPosition);

152count = Math.Min(bytesAvailable, count); // don't return more than they requested, and don't return more than is available 740bytesAvailable = Math.Min(block.Length, (int)(data.End - block.Offset)); 905_length = (int)(Math.Max(_offset + _length, b._offset + b._length) - _offset); 962bytesAvailable = (int)Math.Min(block.Length, _highWaterMark - block.Offset); 1026dataAvailable = (int)Math.Min(block.Length, _highWaterMark - block.Offset); 1058dataAvailable = (int)Math.Min(block.Length, _highWaterMark - block.Offset); 1156block.Length = (int)Math.Min(block.Length, _fullStreamLength - block.Offset);

442scaledInteger = Math.Floor( scaledValue ) ;

517if (!((Math.Max(visEdgeStart.X, visEdgeEnd.X) < Math.Min(uv1.X, uv2.X)) || 518(Math.Min(visEdgeStart.X, visEdgeEnd.X) > Math.Max(uv1.X, uv2.X)) || 519(Math.Max(visEdgeStart.Y, visEdgeEnd.Y) < Math.Min(uv1.Y, uv2.Y)) || 520(Math.Min(visEdgeStart.Y, visEdgeEnd.Y) > Math.Max(uv1.Y, uv2.Y)))) 621if (Math.Abs(visUV1.X - visUV2.X) > Math.Abs(visUV1.Y - visUV2.Y)) 935if (!((Math.Max(visEdgeStart.X, visEdgeEnd.X) < Math.Min(uv1.X, uv2.X)) || 936(Math.Min(visEdgeStart.X, visEdgeEnd.X) > Math.Max(uv1.X, uv2.X)) || 937(Math.Max(visEdgeStart.Y, visEdgeEnd.Y) < Math.Min(uv1.Y, uv2.Y)) || 938(Math.Min(visEdgeStart.Y, visEdgeEnd.Y) > Math.Max(uv1.Y, uv2.Y)))) 1105closestIntersection = ((currClosest - edges[i]._p1Transformed).Length / Math.Sqrt(denom) *

287maxvalue = Math.Max(maxvalue,m[i,j]*m[i,j]); 290maxvalue = Math.Sqrt(maxvalue); 339double root = Math.Sqrt(1+tau*tau); 342_c = 1/Math.Sqrt(1+t*t);

378return radians*(180.0/Math.PI); 383return degrees*(Math.PI/180.0);

126return Math.Round(_fontInfo.Baseline * emSize); 157return Math.Round(_fontInfo.LineSpacing * emSize);

185cch = Math.Min(cch, itemSpanRider.Length); 186cch = Math.Min(cch, typefaceIndexSpanRider.Length); 230int cch = Math.Min(cchRange - ich, typefaceIndexSpanRider.Length); 396int cch = Math.Min(unicodeString.Length - ich, typefaceSpanRider.Length);

1613lengthResolved = Math.Max(startOfNeutrals, startOfDelayed) == PositionInvalid ? 1615((Math.Min(startOfNeutrals, startOfDelayed) == PositionInvalid) ? 1616(Math.Max(startOfNeutrals, startOfDelayed)) : 1617(Math.Min(startOfNeutrals, startOfDelayed))); 1847cchText = Math.Min(cchText, index); 2413sor = Helper.IsOdd(Math.Max(baseLevel, levels[runStart])) ? 2418sor = Helper.IsOdd(Math.Max(lastRunLevel, levels[runStart])) ? 2428eor = Helper.IsOdd(Math.Max(levels[runStart], baseLevel)) ? 2443eor = Helper.IsOdd(Math.Max(levels[runStart], levels[runLimits[runNumber-1] + 1])) ?

141_maxLineWidth = Math.Max(maxLineWidth, 0); 178formatWidth = Math.Max(formatWidth, 0); 179formatWidth = Math.Min(formatWidth, Constants.IdealInfiniteWidth);

1384offsetToNextCaretStopIndex = Math.Min(Length, lsrun.Length - caretStopIndex + lsrun.OffsetToFirstCp + _cpFirst); 1426lscpVisisble = Math.Min(lscpVisisble, _metrics._lscpLim - 1); 1658int lscpEndInSubline = Math.Min( 2001int cch = Math.Min(plsrunSpanRider.Length, cchLeft); 2087cch = Math.Min(cch, cchLeft);

272return Math.Min(0, TextFormatterImp.RealToIdeal(_markerStore.Pap.TextMarkerProperties.Offset) - _store.Settings.TextIndent);

86return ich - cchLast + Math.Min(cchLast, lsdcp - lsdcpLast); 94return ich - cchLast + Math.Min(cchLast, lsdcp - lsdcpLast);

456lstTextMetrics.dvAscent = (int)Math.Round(typeface.Baseline(store.Pap.EmSize, Constants.DefaultIdealToReal, store.Settings.TextSource.PixelsPerDip, fullText.TextFormattingMode)); 457lstTextMetrics.dvMultiLineHeight = (int)Math.Round(typeface.LineSpacing(store.Pap.EmSize, Constants.DefaultIdealToReal, store.Settings.TextSource.PixelsPerDip, fullText.TextFormattingMode)); 715ulInfo.dvpFirstUnderlineOffset = (int)Math.Round(lsrun.EmSize * -underlinePositionInEm); 716ulInfo.dvpFirstUnderlineSize = (int)Math.Round(lsrun.EmSize * underlineThicknessInEm); 769stInfo.dvpLowerStrikethroughOffset = (int)Math.Round(lsrun.EmSize * strikeThroughPositionInEm); 770stInfo.dvpLowerStrikethroughSize = (int)Math.Round(lsrun.EmSize * strikeThroughThicknessInEm); 964int baselineTop = ptOrigin.y + (int)Math.Round(lsrun.EmSize * strikeThroughPositionInEm); 965int overlineTop = baselineTop - (lsrun.BaselineOffset - (int)Math.Round(lsrun.EmSize * strikeThroughThicknessInEm)); 1271penThickness = Math.Abs(penThickness); 1347drawingPenThickness = drawingPenThickness / Math.Abs(unitValue); 2016int expandedBy = Math.Max(0, interWordAdjustTo - adjustedCharWidth); 2023pplsAdjustRight[0][i] = Math.Max(0, adjustedCharWidth - interWordAdjustTo); 2149pplsCompressionRight[0][igi + i] = Math.Max(0, glyphAdvance - interWordCompressTo); 2282int expandedBy = Math.Max(0, interWordExpandTo - glyphAdvance);

72(shapeable != null ? (int)Math.Round(shapeable.Baseline * realToIdeal) : 0), 73(shapeable != null ? (int)Math.Round(shapeable.Height * realToIdeal) : 0),

298realHeight = Math.Max(realHeight, run.Height); 299realAscent = Math.Max(realAscent, run.Baseline); 300realDescent = Math.Max(realDescent, run.Height - run.Baseline); 335_height = formatter.IdealToReal((int)Math.Round(pap.DefaultTypeface.LineSpacing(pap.EmSize, Constants.DefaultIdealToReal, PixelsPerDip, _settings.TextFormattingMode)), PixelsPerDip); 336_baselineOffset = formatter.IdealToReal((int)Math.Round(pap.DefaultTypeface.Baseline(pap.EmSize, Constants.DefaultIdealToReal, PixelsPerDip, _settings.TextFormattingMode)), PixelsPerDip); 370_idealOffsetUnRounded = (int)Math.Round((paragraphWidth - idealWidthAtTrailing) * 0.5); 853int first = Math.Max(ich, dcp) + _cpFirst; 854int afterLast = Math.Min(ich + run.Length, dcp + textLength) + _cpFirst; 1221cpVisible = Math.Max(cpRunStart, cp); 1253cpVisible = Math.Min(cpRunEnd, cp);

672return Math.Round(value * pixelsPerDip, midpointRounding) / pixelsPerDip; 715value = Math.Max(value, Constants.DefaultIdealToReal); 726int value = (int)Math.Round(i * ToIdeal); 730value = Math.Max(value, 1); 747int value = (int)Math.Floor(i * ToIdeal); 751value = Math.Max(value, 1);

184Math.Min(_characterArray.Length, textSourceCharacterIndexLimit)

185int lscpFirstIndependence = Math.Max( 205_baselineOffset = (int)Math.Round( 216_textAscent = (int)Math.Round(pap.DefaultTypeface.Baseline(pap.EmSize, Constants.DefaultIdealToReal, _pixelsPerDip, fullText.TextFormattingMode)); 217_textHeight = (int)Math.Round(pap.DefaultTypeface.LineSpacing(pap.EmSize, Constants.DefaultIdealToReal, _pixelsPerDip, fullText.TextFormattingMode)); 268_paragraphToText = (int)Math.Round((paragraphWidth + _textStart - _textWidthAtTrailing) * 0.5);

394return (int)Math.Round(properties.FontRenderingEmSize * 0.75 * _textRunLength * realToIdeal);

206looseCharLength = (int)Math.Round(TextStore.TypicalCharactersPerLine * 0.25); 229int lookAheadLimit = Math.Min(runLength, looseCharLength + TextStore.TypicalCharactersPerLine); 255looseCharLength = Math.Min(runLength, endOffset);

358advanceWidthsUnshaped[i] = (int)Math.Round(TextFormatterImp.RoundDipForDisplayMode(glyphMetrics[i].AdvanceWidth * designToEm, pixelsPerDip) * scalingFactor); 370advanceWidthsUnshaped[i] = (int)Math.Round(glyphMetrics[i].AdvanceWidth * designToEm);

524int effectedRangeStart = Math.Max(cpFetched - offset, bounds[0].Position); 525int effectedRangeEnd = Math.Min(cpFetched - offset + runInfo.Length, bounds[bounds.Length - 1].Position); 535int currentRangeEnd = Math.Min(bounds[i].Position, effectedRangeEnd); 569currentPosition = Math.Max(currentPosition, bounds[i + 1].Position); 1137int runLength = Math.Min(span.length, cchToAdd - ichRun); 1225int first = limit - Math.Min(charRange.Length, limitCp - firstCp); 1308int spanLength = Math.Min(runInfoSpanRider.Length, textEffectsSpanRider.Length); 1309int ichEnd = Math.Min(ichRun + spanLength, cchUniform); 1579(int)Math.Round(realToIdeal * runInfo.TextRun.Properties.FontRenderingEmSize), 1734(int)Math.Round(realToIdeal * runInfo.TextRun.Properties.FontRenderingEmSize), 1973textTop = Math.Max(textTop, lsrun.BaselineOffset); 1974textBottom = Math.Max(textBottom, lsrun.Descent); 1994textBottom = Math.Max(textBottom, lsrun.Height + top); 1998textBottom = Math.Max(textBottom, lsrun.Height + textTop); 2062cellAscent = Math.Max(cellAscent, lsrun.BaselineOffset - move); 2063cellDescent = Math.Max(cellDescent, lsrun.Descent + move);

287thousandthOfEm = (short) Math.Round(scaled);

38float eps = ((float)Math.Abs(a) + (float)Math.Abs(b) + 10.0f) * FLT_EPSILON; 48return (float)Math.Abs(a-1.0f) < 10.0f * FLT_EPSILON; 56return (float)Math.Abs(a) < 10.0f * FLT_EPSILON; 65return Math.Abs(denominator) <= Math.Abs(numerator) * INVERSE_FLT_MAX_PRECISION;

290int rightShiftNextByteBy = Math.Abs((countOfBits - _cbitsInPartialByte) - Native.BitsPerByte);

2348_current = _current + (int)Math.Min(celt, Int32.MaxValue - _current);

837weight += Math.Sqrt(da.Width*da.Width + da.Height*da.Height) / 2.0f; 842weight += Math.Sqrt(spine.LengthSquared) / 2.0f; 847weight += Math.Sqrt(da.Width*da.Width + da.Height*da.Height) / 2.0f; 852weight += Math.Sqrt(spine.LengthSquared) / 2.0f;

246double min = Math.Min(shapeBoundingBox.Width, shapeBoundingBox.Height); 247tolerance = Math.Log10(min + min); 370return Math.Sqrt(spine.LengthSquared); 763Math.Ceiling(cutAt[cutAt.Length - 1].EndFIndex) > sourceStylusPoints.Count - 1)); 819Math.Ceiling(cutAt[cutAt.Length - 1].EndFIndex) > sourceStylusPoints.Count - 1)); 871? 0 : (int)Math.Floor(beginFIndex); 875? (sourceStylusPoints.Count - 1) : (int)Math.Ceiling(endFIndex); 929double ceiling = Math.Ceiling(endFIndex);

393selectedDA.Height = Math.Max(selectedDA.Height, DrawingAttributes.DefaultHeight); 394selectedDA.Width = Math.Max(selectedDA.Width, DrawingAttributes.DefaultWidth); 694double newWidth = Math.Sqrt(w.X * w.X + w.Y * w.Y); 695double newHeight = Math.Sqrt(h.X * h.X + h.Y * h.Y);

16return degrees * Math.PI / 180.0; 24return radians * 180.0 / Math.PI;

506Radius = (float)Math.Max(1.0, pivot.Radius)

2171return (Math.Abs(newPosition.X - _lastClick.X) < doubleClickDeltaX) && 2172(Math.Abs(newPosition.Y - _lastClick.Y) < doubleClickDeltaY);

533output[x] = (int)Math.Round(stylusPoint.X * StrokeCollectionSerializer.AvalonToHimetricMultiplier); 534output[x + 1] = (int)Math.Round(stylusPoint.Y * StrokeCollectionSerializer.AvalonToHimetricMultiplier); 602output[0][b] = (int)Math.Round(stylusPoint.X * StrokeCollectionSerializer.AvalonToHimetricMultiplier); 603output[1][b] = (int)Math.Round(stylusPoint.Y * StrokeCollectionSerializer.AvalonToHimetricMultiplier);

452_flickDirectionRadians = Math.Atan2(newData.PhysicalPoint.Y - _flickStartPhysical.Y, newData.PhysicalPoint.X - _flickStartPhysical.X); 484return ((180 * radians / Math.PI) + 360) % 360; 495return Math.Sqrt(Math.Pow((p1.X - p2.X), 2) + Math.Pow((p1.Y - p2.Y), 2));

494return new Point(Math.Round(pt.X), Math.Round(pt.Y)); 510return new Point(Math.Round(pt.X), Math.Round(pt.Y)); 1292int elapsedTime = Math.Abs(unchecked(stylusDownEventArgs.Timestamp - _lastTapTimeTicks)); 1298bool isSameSpot = (Math.Abs(ptPixels.X - _lastTapPoint.X) < doubleTapSize.Width) && 1299(Math.Abs(ptPixels.Y - _lastTapPoint.Y) < doubleTapSize.Height);

176ptTablet.X = (int)Math.Round(ptTablet.X); // Make sure we snap to whole window pixels. 177ptTablet.Y = (int)Math.Round(ptTablet.Y);

93float exponent = (float)Math.Pow(10, mappedExponent);

127Size mouseDoubleTapDefault = new Size(Math.Max(1, MS.Win32.SafeSystemMetrics.DoubleClickDeltaX / 2), 128Math.Max(1, MS.Win32.SafeSystemMetrics.DoubleClickDeltaY / 2)); 138_doubleTapSize = new Size((int)Math.Round((ScreenSize.Width * DoubleTapDelta) / dwXValue), 139(int)Math.Round((ScreenSize.Height *DoubleTapDelta) / dwYValue)); 143_doubleTapSize.Width = Math.Max(mouseDoubleTapDefault.Width, _doubleTapSize.Width); 144_doubleTapSize.Height = Math.Max(mouseDoubleTapDefault.Height, _doubleTapSize.Height);

209if (context.QueuedInRangeCount > 0 || (Math.Abs(unchecked(timestamp - context.LastInRangeTime)) <= 500)) 512ptTablet.X = (int)Math.Round(ptTablet.X); // Make sure we snap to whole window pixels. 513ptTablet.Y = (int)Math.Round(ptTablet.Y);

1090int timeSpan = Math.Abs(unchecked(stylusDownEventArgs.Timestamp - stylusDevice.LastTapTime)); 1094bool isSameSpot = (Math.Abs(pPixelPoint.X - pLastPixelPoint.X) < doubleTapSize.Width) && 1095(Math.Abs(pPixelPoint.Y - pLastPixelPoint.Y) < doubleTapSize.Height); 3251if (Math.Abs(unchecked(timestamp - _lastInRangeTime)) <= 500) 3596pt.X = (int)Math.Round(pt.X); // Make sure we return whole numbers (pixels are whole numbers) 3597pt.Y = (int)Math.Round(pt.Y);

1504if ((Math.Abs(_lastMouseScreenLocation.X - dragPosition.X) > delta.Width) || 1505(Math.Abs(_lastMouseScreenLocation.Y - dragPosition.Y) > delta.Height))

281Size mouseDragDefault = new Size(Math.Max(1, SafeSystemMetrics.DragDeltaX / 2), 282Math.Max(1, SafeSystemMetrics.DragDeltaY / 2)); 283Size mouseDoubleTapDefault = new Size(Math.Max(1, SafeSystemMetrics.DoubleClickDeltaX / 2), 284Math.Max(1, SafeSystemMetrics.DoubleClickDeltaY / 2)); 294_cancelSize = new Size((int)Math.Round((ScreenSize.Width * stylusLogic.CancelDelta) / dwXValue), 295(int)Math.Round((ScreenSize.Height * stylusLogic.CancelDelta) / dwYValue)); 299_cancelSize.Width = Math.Max(mouseDragDefault.Width, _cancelSize.Width); 300_cancelSize.Height = Math.Max(mouseDragDefault.Height, _cancelSize.Height); 302_doubleTapSize = new Size((int)Math.Round((ScreenSize.Width * stylusLogic.DoubleTapDelta) / dwXValue), 303(int)Math.Round((ScreenSize.Height * stylusLogic.DoubleTapDelta) / dwYValue)); 307_doubleTapSize.Width = Math.Max(mouseDoubleTapDefault.Width, _doubleTapSize.Width); 308_doubleTapSize.Height = Math.Max(mouseDoubleTapDefault.Height, _doubleTapSize.Height);

336originOffsetX = (int)Math.Round(originTabletCoord.X); 337originOffsetY = (int)Math.Round(originTabletCoord.Y);

921size = new Point(Math.Ceiling(size.X), Math.Ceiling(size.Y));

783(float)(Math.Ceiling((double)(_hwndClientRectInScreenCoords.right - _hwndClientRectInScreenCoords.left))), 784(float)(Math.Ceiling((double)(_hwndClientRectInScreenCoords.bottom - _hwndClientRectInScreenCoords.top)))); 1594(float)(Math.Ceiling((double)(_hwndClientRectInScreenCoords.right - _hwndClientRectInScreenCoords.left))), 1595(float)(Math.Ceiling((double)(_hwndClientRectInScreenCoords.bottom - _hwndClientRectInScreenCoords.top))));

431specificity = Math.Max(GetSubtagCount(languageTag), 1 + GetSpecificity(culture.Parent, maxDepth - 1));

44double amp = Math.Max(0.0, Amplitude); 45return Math.Pow(normalizedTime, 3.0) - normalizedTime * amp * Math.Sin(Math.PI * normalizedTime);

82double bounces = Math.Max(0.0, (double)Bounces); 92double pow = Math.Pow(bounciness, bounces); 105double bounceAtT = Math.Log(-unitAtT * (1.0-bounciness) + 1.0, bounciness); 106double start = Math.Floor(bounceAtT); 111double startTime = (1.0 - Math.Pow(bounciness, start)) / (oneMinusBounciness * sumOfUnits); 112double endTime = (1.0 - Math.Pow(bounciness, end)) / (oneMinusBounciness * sumOfUnits); 118double amplitude = Math.Pow(1.0 / bounciness, (bounces - start));

16normalizedTime = Math.Max(0.0, Math.Min(1.0, normalizedTime)); 17return 1.0 - Math.Sqrt(1.0 - normalizedTime * normalizedTime);

2160timeUntilNextBoundary = DivideTimeSpan(_currentDuration.TimeSpan, Math.Abs(parentSpeed)); 4183long error = (long)Math.Max(_appliedSpeedRatio, 1.0); 4192Debug.Assert(Math.Abs(optimizedInputTime - inputTime) <= error,

205desiredFrameRate = Math.Max(desiredFrameRate, currentDesiredFrameRate.Value);

304double angle = Math.Acos(x) * (180.0 / Math.PI);

72double oscillations = Math.Max(0.0, (double)Oscillations); 73double springiness = Math.Max(0.0, Springiness); 81expo = (Math.Exp(springiness * normalizedTime) - 1.0) / (Math.Exp(springiness) - 1.0); 84return expo * (Math.Sin((Math.PI * 2.0 * oscillations + Math.PI * 0.5) * normalizedTime));

54return (Math.Exp(factor * normalizedTime) - 1.0) / (Math.Exp(factor) - 1.0);

362absdx = Math.Abs(dx); 377if (Math.Abs(x - time) < accuracy * absdx)

47double power = Math.Max(0.0, Power); 48return Math.Pow(normalizedTime, power);

16return 1.0 - Math.Sin(Math.PI * 0.5 * (1 - normalizedTime));

104count = Math.Min(count, 4);

494int cbDataForThisChunk = Math.Min(cbDataSize, 530int newChunkSize = Math.Min(2*_chunkList[_chunkList.Count-1].Length, c_maxChunkSize);

1055return (float)Math.Pow(((double)val + 0.055) / 1.055, 2.4); 1079return ((byte)((255.0f * ((1.055f * (float)Math.Pow((double)val, (1.0 / 2.4))) - 0.055f)) + 0.5f));

45double direction = Math.PI/180 * Direction; 46double offsetX = depth * Math.Cos(direction); 47double offsetY = depth * Math.Sin(direction);

103currentCenter.X - Math.Abs(currentRadiusX), 104currentCenter.Y - Math.Abs(currentRadiusY), 1052.0 * Math.Abs(currentRadiusX), 1062.0 * Math.Abs(currentRadiusY)); 169strokeThickness = Math.Abs(pen.Thickness); 173center.X - Math.Abs(radiusX)-0.5*strokeThickness, 174center.Y - Math.Abs(radiusY)-0.5*strokeThickness, 1752.0 * Math.Abs(radiusX)+strokeThickness, 1762.0 * Math.Abs(radiusY)+strokeThickness); 254double area = Math.Abs(RadiusX * RadiusY) * Math.PI; 260area *= Math.Abs(transform.Value.Determinant); 364radiusX = Math.Abs(radiusX); 365radiusY = Math.Abs(radiusY);

316pAdvances[i] = Math.Max(0, (int)((metrics.BlackBoxWidth + metrics.LeftSideBearing + metrics.RightSideBearing) * emSize));

344i = Math.Min(limit, i + formatRider.Length); 418i = Math.Min(limit, i + formatRider.Length); 473i = Math.Min(limit, i + formatRider.Length); 526i = Math.Min(limit, i + formatRider.Length); 585i = Math.Min(limit, i + formatRider.Length); 644i = Math.Min(limit, i + formatRider.Length); 696i = Math.Min(limit, i + formatRider.Length); 749i = Math.Min(limit, i + formatRider.Length); 802i = Math.Min(limit, i + formatRider.Length); 854i = Math.Min(limit, i + formatRider.Length); 995return _that._maxTextWidths[Math.Min(line, _that._maxTextWidths.Length - 1)]; 1139Math.Min(textSourcePosition + line.Length - 1, _that._text.Length - 1) 1650int x0 = Math.Max(enumerator.Position, startIndex); 1651int x1 = Math.Min(enumerator.Position + enumerator.Length, startIndex + count); 1802accBlackBoxLeft = Math.Min(accBlackBoxLeft, blackBoxLeft); 1803accBlackBoxRight = Math.Max(accBlackBoxRight, blackBoxRight); 1804accBlackBoxBottom = Math.Max(accBlackBoxBottom, blackBoxBottom); 1805accBlackBoxTop = Math.Min(accBlackBoxTop, blackBoxTop); 1811metrics.Width = Math.Max(metrics.Width, currentLine.Width); 1812metrics.WidthIncludingTrailingWhitespace = Math.Max(metrics.WidthIncludingTrailingWhitespace, currentLine.WidthIncludingTrailingWhitespace); 1813lineStartOfLongestLine = Math.Min(lineStartOfLongestLine, currentLine.Start);

1418double inflation = Math.Min(_renderingEmSize / 7.0, 1.0); 1460return Math.Max(advance, oneSideBearing + otherSideBearing + 1); 1767_baseVectorX = Math.Sqrt(m11 * m11 + m12 * m12); 1773_baseVectorY = _baseVectorX == 0 ? 0 : Math.Abs(m11 * m22 - m12 * m21) / _baseVectorX;

72Math.Max( 198int roundedShapingAdvance = (int)Math.Round(_idealAdvanceTotal + shapingAdvance - _currentAdvanceTotal); 199int roundedFontAdvance = (int)Math.Round(fontAdvance); 220int offset = (int)Math.Round(_offsets[glyph].X * _milToEm); 228offset = (int)Math.Round(_offsets[glyph].Y * _milToEm); 294lastCaretStop = Math.Min(i | 3, _caretStops.Count - 1);

1353advanceWidthsUnshaped[i] = (int)Math.Round(TextFormatterImp.RoundDipForDisplayMode(glyphMetrics[i].AdvanceWidth * designToEm, pixelsPerDip) * scalingFactor); 1361advanceWidthsUnshaped[i] = (int)Math.Round(glyphMetrics[i].AdvanceWidth * designToEm); 1369int missingGlyphWidth = (int)Math.Round(TextFormatterImp.RoundDip(emSize * GetAdvanceWidth(0, pixelsPerDip, textFormattingMode, isSideways), pixelsPerDip, textFormattingMode) * scalingFactor);

361int percentComplete = (int)Math.Floor(100.0 * (double)entry.outputStream.Length / (double)entry.contentLength);

285int numColors = Math.Min(256, _colors.Count);

479return new Size(Math.Max(0, GetWidthInternal()), 480Math.Max(0, GetHeightInternal()));

136scaleX = Math.Abs(m.M11); 137scaleY = Math.Abs(m.M22); 155scaleX = Math.Abs(m.M12); 156scaleY = Math.Abs(m.M21); 195uint width = Math.Max(1, (uint)(scaleX * _source.PixelWidth + 0.5)); 196uint height = Math.Max(1, (uint)(scaleY * _source.PixelHeight + 0.5));

224angle = angle * (1.0/180.0) * System.Math.PI; 226return (new Point(System.Math.Cos(angle), System.Math.Sin(angle)));

86_highWaterMark = Math.Max(_highWaterMark, _size); 124_highWaterMark = Math.Max(_highWaterMark, _size); 154_highWaterMark = Math.Max(_highWaterMark, _size); 197int newSize = Math.Max(_highWaterMark, s_initialSize);

120int sqrt = (int) Math.Sqrt(number); 592nextTickNeeded = TimeSpan.FromTicks(Math.Max(nextTickNeeded.Ticks, minimumDelay.Ticks)); 771_animationRenderRate = Math.Max(_adjustedRefreshRate, _timeManager.GetMaxDesiredFrameRate()); 823_animationRenderRate = Math.Min(_animationRenderRate, 1000);

377_curIndex = Math.Min(_curIndex+8, _pathLength); // "Infinity" has 8 characters 387_curIndex = Math.Min(_curIndex+3, _pathLength); // "NaN" has 3 characters

205strokeThickness = Math.Abs(pen.Thickness); 299double area = Math.Abs(rect.Width * rect.Height); 302area -= Math.Abs(radiusX * radiusY) * (4.0 - Math.PI); 308area *= Math.Abs(transform.Value.Determinant); 478radiusX = Math.Min(rect.Width * (1.0 / 2.0), Math.Abs(radiusX)); 479radiusY = Math.Min(rect.Height * (1.0 / 2.0), Math.Abs(radiusY));

485int newSize = Math.Max((_buffer.Length << 1) - (_buffer.Length >> 1), cbRequiredSize);

91int maxOffset = (charBuffer == null) ? 0 : Math.Max(0, charBuffer.Count - 1);

652nominalWidths[i] = (int)Math.Round(TextFormatterImp.RoundDipForDisplayMode(glyphMetrics[i].AdvanceWidth * designToEm, pixelsPerDip) * toIdeal); 661nominalWidths[i] = (int)Math.Round(glyphMetrics[i].AdvanceWidth * designToEm);

246InternalCapacity = Math.Max(min, (int)(InternalCapacity * c_growFactor));

580Array.Copy(_tail, reallocatedTail, Math.Min(_tail.Length, newLength));

122Math.E, Math.PI, Math.E * Math.PI, 55.0

230return x + 0.1*Math.Abs(x) + 1.0;

84double halfWidthDepthRatio = Math.Tan(fov/2); 132double halfWidthDepthRatio = Math.Tan(fov/2);

89double angleInRadians = angleInDegrees * (Math.PI / 180.0); 93Vector3D v = (axisOfRotation / length) * Math.Sin(0.5 * angleInRadians); 97_w = Math.Cos(0.5 * angleInRadians); 161double msin = Math.Sqrt(_x*_x + _y*_y + _z*_z); 170double maxcoeff = Math.Max(Math.Abs(_x),Math.Max(Math.Abs(_y),Math.Abs(_z))); 174msin = Math.Sqrt(x*x + y*y + z*z); 180return Math.Atan2(msin,mcos) * (360.0 / Math.PI); 260double rmax = 1.0/Max(Math.Abs(_x), 261Math.Abs(_y), 262Math.Abs(_z), 263Math.Abs(_w)); 271double normInverse = 1.0 / Math.Sqrt(norm2); 445double max = Math.Max(Math.Max(Math.Abs(_x),Math.Abs(_y)), 446Math.Max(Math.Abs(_z),Math.Abs(_w))); 453double smallLength = Math.Sqrt(x*x+y*y+z*z+w*w); 457return Math.Sqrt(norm2); 561double theta = t * Math.PI; 563scaleFrom = Math.Cos(theta); 564scaleTo = Math.Sin(theta); 569double omega = Math.Acos(cosOmega); 570double sinOmega = Math.Sqrt(1.0 - cosOmega*cosOmega); 571scaleFrom = Math.Sin((1.0 - t) * omega) / sinOmega; 572scaleTo = Math.Sin(t * omega) / sinOmega; 580double lengthOut = lengthFrom * Math.Pow(lengthTo/lengthFrom, t);

99return Math.Sign(x.DistanceToRayOrigin - y.DistanceToRayOrigin);

97_x = Math.Min(point1._x, point2._x); 98_y = Math.Min(point1._y, point2._y); 99_z = Math.Min(point1._z, point2._z); 100_sizeX = Math.Max(point1._x, point2._x) - _x; 101_sizeY = Math.Max(point1._y, point2._y) - _y; 102_sizeZ = Math.Max(point1._z, point2._z) - _z; 438double x = Math.Max(_x, rect._x); 439double y = Math.Max(_y, rect._y); 440double z = Math.Max(_z, rect._z); 441_sizeX = Math.Min(_x + _sizeX, rect._x + rect._sizeX) - x; 442_sizeY = Math.Min(_y + _sizeY, rect._y + rect._sizeY) - y; 443_sizeZ = Math.Min(_z + _sizeZ, rect._z + rect._sizeZ) - z; 476double x = Math.Min(_x, rect._x); 477double y = Math.Min(_y, rect._y); 478double z = Math.Min(_z, rect._z); 479_sizeX = Math.Max(_x + _sizeX, rect._x + rect._sizeX) - x; 480_sizeY = Math.Max(_y + _sizeY, rect._y + rect._sizeY) - y; 481_sizeZ = Math.Max(_z + _sizeZ, rect._z + rect._sizeZ) - z;

65return Math.Sqrt(_x * _x + _y * _y + _z * _z); 90double m = Math.Abs(_x); 91double absy = Math.Abs(_y); 92double absz = Math.Abs(_z); 106double length = Math.Sqrt(_x * _x + _y * _y + _z * _z); 172theta = Math.PI - 2.0 * Math.Asin((-vector1 - vector2).Length / 2.0); 176theta = 2.0 * Math.Asin((vector1 - vector2).Length / 2.0); 468return new Size3D(Math.Abs(vector._x), Math.Abs(vector._y), Math.Abs(vector._z));

1096newValue = Math.Round(value * dpiScale) / dpiScale; 1107newValue = Math.Round(value);

326(int)Math.Round(x), 327(int)Math.Round(y), // new X and Y positions

84return Math.Abs(to - from); 90Math.Pow(GetSegmentLengthDouble(from.Left, to.Left), 2.0) 91+ Math.Pow(GetSegmentLengthDouble(from.Top, to.Top), 2.0) 92+ Math.Pow(GetSegmentLengthDouble(from.Right, to.Right), 2.0) 93+ Math.Pow(GetSegmentLengthDouble(from.Bottom, to.Bottom), 2.0); 95return Math.Sqrt(totalLength);

854sign = Math.Sign(next.Left - current.Left);

346return (((int)Math.Ceiling(original) + (nBitsCount - 1)) / nBitsCount) * nBitsCount;

97newSize.Width = Math.Max(newSize.Width, left + child.DesiredSize.Width); 101newSize.Width = Math.Max(newSize.Width, child.DesiredSize.Width); 107newSize.Height = Math.Max(newSize.Height, top + child.DesiredSize.Height); 111newSize.Height = Math.Max(newSize.Height, child.DesiredSize.Height);

1057if (DoubleUtil.GreaterThan(Math.Abs(offsetX), Math.Abs(_offsetX))) 1063offset = Math.Max(offset, -(rectStickyNote.Left - rectPage.Left)); 1069if (DoubleUtil.GreaterThan(Math.Abs(offsetY), Math.Abs(_offsetY))) 1074offset = Math.Max(offset, -(rectStickyNote.Top - rectPage.Top));

398int n = Math.Min(mid - left, right - mid);

671PrivateCapacity = Math.Max(min, PrivateCapacity * 2);

323if (Math.Abs(pageNumber - _firstVisiblePageNumber) > 1) 584double clippedHorizontalOffset = Math.Min(_horizontalOffset, ExtentWidth - ViewportWidth); 585clippedHorizontalOffset = Math.Max(clippedHorizontalOffset, 0.0); 627double clippedVerticalOffset = Math.Min(_verticalOffset, ExtentHeight - ViewportHeight); 628clippedVerticalOffset = Math.Max(clippedVerticalOffset, 0.0); 1224pageOffset = new Point(Math.Max(ViewportWidth, ExtentWidth) - (xOffset + pageSize.Width), yOffset); 1452visiblePages.Add(_childrenCollection[_firstPageVisualIndex + j - Math.Max(0, firstPage)]); 1606double centerWidth = Math.Max(ViewportWidth, ExtentWidth); 2229(int)Math.Floor(ViewportWidth / 2234maxColumns = Math.Min(maxColumns, _pageCache.PageCount); 2235maxColumns = Math.Min(maxColumns, DocumentViewerConstants.MaximumMaxPagesAcross); 2246int rows = (int)Math.Floor((double)(_pageCache.PageCount / columns)); 2258double aspectDiff = Math.Abs(layoutAspect - viewportAspect); 2370newScale = Math.Max(newScale, CurrentMinimumScale); 2371newScale = Math.Min(newScale, DocumentViewerConstants.MaximumScale); 2440scaleFactor = Math.Min(compensatedViewportWidth / rowWidth, compensatedViewportHeight / rowHeight); 2469scaleFactor = Math.Min(compensatedViewportWidth / rowWidth, 2699Math.Max(0.0, (ExtentWidth - row.RowSize.Width) / 2.0) : 0.0;

655while (Math.Abs(pagesMoved) < Math.Abs(count))

84desiredSize.Width = Math.Min(constraint.Width, _formatter.DocumentPage.Size.Width); 85desiredSize.Height = Math.Min(constraint.Height, _formatter.DocumentPage.Size.Height); 134if (Math.Abs(_scrollData.ExtentWidth - _scrollData.ViewportWidth) < 1) 138if (Math.Abs(_scrollData.ExtentHeight - _scrollData.ViewportHeight) < 1) 144Math.Max(0, Math.Min(_scrollData.ExtentWidth - _scrollData.ViewportWidth, _scrollData.HorizontalOffset)), 145Math.Max(0, Math.Min(_scrollData.ExtentHeight - _scrollData.ViewportHeight, _scrollData.VerticalOffset)));

834GoToPage(Math.Max(1, MasterPageNumber - 2)); 842GoToPage(Math.Min(PageCount, MasterPageNumber + 2));

762Invariant.Assert(Math.Abs(request.NewCount) >= Math.Abs(linesMoved)); 834Invariant.Assert(Math.Abs(request.NewCount) >= Math.Abs(pagesMoved)); 982Invariant.Assert(Math.Abs(pagesMoved) <= Math.Abs(count)); 1100horz = Math.Min(Math.Abs(point.X - textViewBounds.Left), Math.Abs(point.X - textViewBounds.Right)); 1108vert = Math.Min(Math.Abs(point.Y - textViewBounds.Top), Math.Abs(point.Y - textViewBounds.Bottom)); 1110textViewProximities[i] = Math.Sqrt(Math.Pow(horz, 2) + Math.Pow(vert, 2)); 1195int closestDistance = Math.Abs(count); 1220int distance = Math.Abs(currentPageNumber - pageNumber);

316double roundedOffset = Math.Round(offset, _findOffsetPrecision); 324double rowOffset = Math.Round(_rowCache[i].VerticalOffset, _findOffsetPrecision); 325double rowHeight = Math.Round(_rowCache[i].RowSize.Height, _findOffsetPrecision); 416startOffset = Math.Round(startOffset, _findOffsetPrecision); 417endOffset = Math.Round(endOffset, _findOffsetPrecision); 423double rowOffset = Math.Round(_rowCache[i].VerticalOffset, _findOffsetPrecision); 475_extentWidth = Math.Max(currentRow.RowSize.Width, _extentWidth); 542_layoutColumns = Math.Min(_layoutColumns, PageCache.PageCount); 543_layoutColumns = Math.Max(1, _layoutColumns); 657pivotPage = Math.Max(0, PageCache.PageCount - columns); 981_extentWidth = Math.Max(newRow.RowSize.Width, _extentWidth); 1109_extentWidth = Math.Max(row.RowSize.Width, _extentWidth); 1377_rowSize.Height = Math.Max(pageSize.Height, _rowSize.Height);

135offset = Math.Max(0, Math.Min(_extent.Width - _viewport.Width, offset)); 157offset = Math.Max(0, Math.Min(_extent.Height - _viewport.Height, offset));

124int runLength = Math.Min(128, position.GetTextRunLength(LogicalDirection.Backward));

503desiredSize.Width = Math.Min(constraint.Width, desiredSize.Width); 504desiredSize.Height = Math.Min(constraint.Height, desiredSize.Height); 697int startOffset = Math.Min(_lineMetrics[_lineMetrics.Count - 1].EndOffset, startPosition.Offset); 698int endOffset = Math.Min(_lineMetrics[_lineMetrics.Count - 1].EndOffset, endPosition.Offset); 705firstLineIndex = Math.Max(firstLineIndex, GetLineIndexFromOffset(startOffset, LogicalDirection.Forward)); 706lastLineIndex = Math.Min(lastLineIndex, GetLineIndexFromOffset(endOffset, LogicalDirection.Backward)); 775int nextLineIndex = Math.Max(0, Math.Min(_lineMetrics.Count - 1, lineIndex + count)); 1791Math.Max(0, Math.Min(_scrollData.ExtentWidth - _scrollData.ViewportWidth, _scrollData.HorizontalOffset)), 1792Math.Max(0, Math.Min(_scrollData.ExtentHeight - _scrollData.ViewportHeight, _scrollData.VerticalOffset))); 1938int endOffset = Math.Min(range.StartIndex + range.PositionsAdded, _host.TextContainer.SymbolCount); 2049int startOffset = Math.Max(_lineMetrics[lineIndex].Offset, unclippedStartOffset); 2050int endOffset = Math.Min(_lineMetrics[lineIndex].EndOffset, unclippedEndOffset); 2145int startOffset = Math.Max(lineStartOffset, unclippedStartOffset); 2146int endOffset = Math.Min(lineEndOffset, unclippedEndOffset); 2205lastLineIndex = (int)Math.Ceiling((viewport.Y + viewport.Height) / _lineHeight) - 1; 2208firstLineIndex = Math.Max(0, Math.Min(firstLineIndex, _lineMetrics.Count - 1)); 2209lastLineIndex = Math.Max(0, Math.Min(lastLineIndex, _lineMetrics.Count - 1)); 2281desiredSize.Width = Math.Max(desiredSize.Width, line.Width); 2555int lastCoveredCharOffset = range.StartIndex + Math.Max(range.PositionsAdded, range.PositionsRemoved); 2651desiredSize.Width = Math.Max(desiredSize.Width, _lineMetrics[i].Width); 2714int lineIndex = Math.Max(oldLineVisualsIndex, firstLineIndex); 2715int lineCount = Math.Min(oldLastLineIndex, firstLineIndex + count - 1) - lineIndex + 1; 2809count = Math.Max(0, count); 2815count = Math.Min(count, _viewportLineVisuals.Count - start); 2993int rangeStart = Math.Max(viewportStart, selectionStart); 2994int rangeSize = Math.Min(viewportEnd, selectionEnd) - rangeStart; 3130padding = Math.Max(0, viewport.Height - _contentSize.Height);

202_cpFirst = Math.Min(_cpFirst, cpFirst); 203_cpLast = Math.Max(_cpLast, cpLast); 227_ranges[i * 2] = Math.Min(_ranges[i * 2], cpFirst); 228_ranges[i * 2 + 1] = Math.Max(_ranges[i * 2 + 1], cpLast); 250_ranges[pos * 2 + 1] = Math.Max(_ranges[pos * 2 + 1], _ranges[(pos + 1) * 2 + 1]); 475int depth = Math.Min(ancestorsStart.Count, ancestorsEnd.Count);

2107double distance = Math.Abs(point.X - midPoint.X) + Math.Abs(point.Y - midPoint.Y);

167lineIndex = Math.Max(0, lineIndex + count); 168lineIndex = Math.Min(lines.Count - 1, lineIndex); 578lineIndex = Math.Max(Math.Min((int)(point.Y / approximatedLineHeight), lines.Count - 1), 0); 724siblingGap = Math.Max(lineBox.X - (siblingLineBox.X + siblingLineBox.Width), 0); 753siblingGap = Math.Max(siblingLineBox.X - (lineBox.X + lineBox.Width), 0);

576Readability readability = (Readability)Math.Min( 582Modifiability modifiability = (Modifiability)Math.Min(

1081headerSize.Height = Math.Max(itemsCorrectionFactor.Top, headerSize.Height); 1085headerSize.Height = Math.Max(virtualizingElement.DesiredSize.Height, headerSize.Height); 1087headerSize.Width = Math.Max(virtualizingElement.DesiredSize.Width, headerSize.Width); 1118itemPixelSize.Width = Math.Max(desiredSize.Width, itemPixelSize.Width); 1131itemPixelSizeBeforeViewport.Width = Math.Max(desiredSize.Width, itemPixelSizeBeforeViewport.Width); 1143itemPixelSizeInViewport.Width = Math.Max(desiredSize.Width, itemPixelSizeInViewport.Width); 1154itemPixelSizeAfterViewport.Width = Math.Max(desiredSize.Width, itemPixelSizeAfterViewport.Width);

113double step = Math.Sqrt(MinDistanceSquared / distanceSquared); 237&& DoubleUtil.GreaterThanOrClose(point.X, Math.Min(prevLassoPoint.X, lassoPoint.X)) 238&& DoubleUtil.LessThanOrClose(point.X, Math.Max(prevLassoPoint.X, lassoPoint.X))) 247if (DoubleUtil.GreaterThanOrClose(point.X, Math.Max(prevLassoPoint.X, lassoPoint.X))) 253if ((0 == i) && DoubleUtil.AreClose(point.X, Math.Max(prevLassoPoint.X, lassoPoint.X))) 258else if (DoubleUtil.GreaterThanOrClose(point.X, Math.Min(prevLassoPoint.X, lassoPoint.X)))

220int xHotspot = (int)Math.Round(hotspot.X - drawingBounds.Left); 221int yHotspot = (int)Math.Round(hotspot.Y - drawingBounds.Top); 347double maxLength = Math.Min(SystemParameters.PrimaryScreenWidth / 2, SystemParameters.PrimaryScreenHeight / 2);

81Math.Max(TextDpi.FromTextDpi(dvrAvailable), 0));

66_rect.du = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.du); 67_rect.dv = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.dv);

528fsrcToFillSubtrack.u = Math.Max(Math.Min(fsrcToFillSubtrack.u, fsrcToFill.u + fsrcToFill.du - 1), fsrcToFill.u); 529fsrcToFillSubtrack.du = Math.Max(fsrcToFillSubtrack.du, 0); 542fsrcToFillSubtrack.v = Math.Max(Math.Min(fsrcToFillSubtrack.v, fsrcToFill.v + fsrcToFill.dv - 1), fsrcToFill.v); 543fsrcToFillSubtrack.dv = Math.Max(fsrcToFillSubtrack.dv, 0); 603dvrUsed = Math.Min(fsrcToFill.dv, dvrUsed); 686urSubtrack = Math.Max(Math.Min(urTrack + mbp.MBPLeft, urTrack + durTrack - 1), urTrack); 687durSubtrack = Math.Max(durTrack - (mbp.MBPLeft + mbp.MBPRight), 0); 816urSubtrack = Math.Max(Math.Min(urTrack + mbp.MBPLeft, urTrack + durTrack - 1), urTrack); 817durSubtrack = Math.Max(durTrack - (mbp.MBPLeft + mbp.MBPRight), 0);

104int adjust = Math.Min(_dtrs[i].PositionsAdded, dtr.PositionsRemoved - delta); 118int adjust = Math.Min(dtr.PositionsRemoved, _dtrs[i].PositionsAdded - delta);

184value = Math.Max(1, Math.Min(value, structuralCache.CurrentFormatContext.PageHeight)); 189value = Math.Max(1, Math.Min(value, structuralCache.CurrentFormatContext.PageHeight - pageMargin.Top - pageMargin.Bottom)); 257width = Math.Min(width, pageWidth);

84_contentRect.du = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.du - mbp.BPRight - mbp.BPLeft); 86_contentRect.dv = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.dv - mbp.BPBottom - mbp.BPTop); 89_paddingRect.du = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.du - mbp.BorderRight - mbp.BorderLeft); 91_paddingRect.dv = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.dv - mbp.BorderBottom - mbp.BorderTop);

161int subpageWidth = Math.Max(1, TextDpi.ToTextDpi(anchorLimitedWidth) - (mbp.BPLeft + mbp.BPRight)); 170int subpageHeight = Math.Max(1, TextDpi.ToTextDpi(anchorLimitedHeight) - (mbp.BPTop + mbp.BPBottom)); 617width = Math.Max(TextDpi.MinWidth, maxTotalWidth - elementMarginWidth); 646height = Math.Max(TextDpi.MinWidth, maxTotalHeight - elementMarginHeight);

205_contentRect.du = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.du - mbp.BPRight - mbp.BPLeft); 207_contentRect.dv = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.dv - mbp.BPBottom - mbp.BPTop); 210_paddingRect.du = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.du - mbp.BorderRight - mbp.BorderLeft); 212_paddingRect.dv = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.dv - mbp.BorderBottom - mbp.BorderTop);

216dvrAvailable = Math.Min(dvrAvailable, PTS.dvBottomUndefined / 2); 222dvrAvailable = Math.Min(dvrAvailable, TextDpi.ToTextDpi(StructuralCache.CurrentFormatContext.PageHeight)); 235subpageHeight = Math.Max(1, dvrAvailable - (mbp.MBPTop + mbp.MBPBottom)); 668subpageWidth = Math.Max(1, durSpecified - (mbp.BPLeft + mbp.BPRight)); 673subpageWidth = Math.Max(1, durAvailable - (mbp.MBPLeft + mbp.MBPRight)); 679subpageWidth = Math.Max(1, durAvailable - (mbp.MBPLeft + mbp.MBPRight)); 882return Math.Min(desiredSize, spaceAvailable);

110dvrSuppressible = Math.Max(0, TextDpi.ToTextDpi(_line.OverhangAfter));

198state.number = Math.DivRem(state.number, state.b, out int remainder) - state.disjoint;

167_maxPositive = Math.Max(_maxPositive, mcs._maxPositive); 168_minNegative = Math.Min(_minNegative, mcs._minNegative);

838return Math.Max(1, Math.Min(PTS.Restrictions.tscColumnRestriction-1, columns)); // at least 1 column is required 885columnWidth = Math.Max(1, Math.Min(columnWidth, pageWidth)); 887freeSpace = Math.Max(0, freeSpace); 928pfscolinfo[i].durBefore = Math.Max(0, pfscolinfo[i].durBefore); 929pfscolinfo[i].durWidth = Math.Max(1, pfscolinfo[i].durWidth); 960pfscolinfo[i].durBefore = Math.Max(0, pfscolinfo[i].durBefore); 961pfscolinfo[i].durWidth = Math.Max(1, pfscolinfo[i].durWidth);

1532for(int breakIndex = 0; breakIndex < Math.Min(textBreakpoints.Count, nLineVariantsAlloc); breakIndex++)

778rect.dv = Math.Max(rect.dv, bbox.fsrc.dv); 781_calculatedSize.Width = Math.Max(TextDpi.MinWidth, TextDpi.FromTextDpi(rect.du)); 782_calculatedSize.Height = Math.Max(TextDpi.MinWidth, TextDpi.FromTextDpi(rect.dv)); 786_contentSize.Width = Math.Max(Math.Max(TextDpi.FromTextDpi(bbox.fsrc.du), TextDpi.MinWidth), _calculatedSize.Width); 787_contentSize.Height = Math.Max(TextDpi.MinWidth, TextDpi.FromTextDpi(bbox.fsrc.dv)); 793_contentSize.Height = Math.Max(_contentSize.Height, _calculatedSize.Height);

97_contentRect.du = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.du - mbp.BPRight - mbp.BPLeft); 99_contentRect.dv = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.dv - mbp.BPBottom - mbp.BPTop); 102_paddingRect.du = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.du - mbp.BorderRight - mbp.BorderLeft); 104_paddingRect.dv = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.dv - mbp.BorderBottom - mbp.BorderTop);

182subpageWidth = Math.Max(1, subpageWidth - (mbp.MBPLeft + mbp.MBPRight)); 191subpageHeight = Math.Max(1, subpageHeight - (marginTop + mbp.BPTop)); 245dvrUsed = Math.Max(dvrUsed, fsbbox.fsrc.dv + fsbbox.fsrc.v); 246fsrcToFill.du = Math.Max(fsrcToFill.du, fsbbox.fsrc.du + fsbbox.fsrc.u); 289fsbbox.fsrc.du = Math.Max(fsrcToFill.du - (mbp.MarginLeft + mbp.MarginRight), 0); 290fsbbox.fsrc.dv = Math.Max(dvrUsed - dvrTopSpace, 0); 369subpageWidth = Math.Max(1, subpageWidth - (mbp.MBPLeft + mbp.MBPRight)); 441dvrUsed = Math.Max(dvrUsed, fsbbox.fsrc.dv + fsbbox.fsrc.v); 442durTrack = Math.Max(durTrack, fsbbox.fsrc.du + fsbbox.fsrc.u); 452fsbbox.fsrc.du = Math.Max(durTrack - (mbp.MarginLeft + mbp.MarginRight), 0); 453fsbbox.fsrc.dv = Math.Max(dvrUsed - dvrTopSpace, 0); 529subpageWidth = Math.Max(1, subpageWidth - (mbp.MBPLeft + mbp.MBPRight)); 600dvrUsed = Math.Max(dvrUsed, fsbbox.fsrc.dv + fsbbox.fsrc.v); 601durTrack = Math.Max(durTrack, fsbbox.fsrc.du + fsbbox.fsrc.u); 611fsbbox.fsrc.du = Math.Max(durTrack - (mbp.MarginLeft + mbp.MarginRight), 0); 612fsbbox.fsrc.dv = Math.Max(dvrUsed - dvrTopSpace, 0);

652int du = Math.Min(Math.Abs(rect.u - u), Math.Abs(rect.u + rect.du - u)); 653int dv = Math.Min(Math.Abs(rect.v - v), Math.Abs(rect.v + rect.dv - v)); 1001int iDistance = Math.Abs((cpc.Rect.u + cpc.Rect.du / 2) - suggestedU); 1077int iDistance = Math.Abs((cpc.Rect.u + cpc.Rect.du / 2) - suggestedU); 1934Math.Min(_calculatedColumns.Length, columns)); 2426Math.Max(_rect.du - (mbpInfo.BPRight + mbpInfo.BPLeft), 1), 2427Math.Max(_rect.dv - calculatedBPBottom - calculatedBPTop, 1)

745int dcpStart = Math.Max(cpStartTextPointer, cpParagraphStart) - cpParagraphStart; 749int dcpEnd = Math.Min(cpEndTextPointer, cpParagraphEnd) - cpParagraphStart; 1414int countVisualsShiftBeforeChange = Math.Min(Math.Max(lineIndexToBeginRemoval - _lineIndexFirstVisual, 0), lineVisuals.Count); 1431int actualLinesToRemove = Math.Min(Math.Max(lineIndexToBeginRemoval - _lineIndexFirstVisual + cLinesToRemove, 0), lineVisuals.Count); 1459int actualLinesToRemove = Math.Min(cLinesToRemove, lineVisuals.Count - (lineIndexToBeginRemoval - _lineIndexFirstVisual)); 1879int dcpRangeStartForThisLine = Math.Max(lineDesc.dcpFirst, dcpStart); 1882int cchRangeForThisLine = Math.Max(Math.Min(lineDesc.dcpLim, dcpEnd) - dcpRangeStartForThisLine, 1); 1989int dcpRangeStartForThisElem = Math.Max(elemDesc.dcpFirst, dcpStart); 1992int cchRangeForThisElem = Math.Max(Math.Min(elemDesc.dcpLim, dcpEnd) - dcpRangeStartForThisElem, 1); 2084lineRect.Width = Math.Max(lineVisual.WidthIncludingTrailingWhitespace, 0); 2195elementRect.Width = Math.Max(lineVisual.WidthIncludingTrailingWhitespace, 0); 3133line.GetGlyphRuns(glyphRuns, Math.Max(dcpStart, lineDesc.dcpFirst), Math.Min(dcpEnd, lineDesc.dcpLim)); 3195line.GetGlyphRuns(glyphRuns, Math.Max(dcpStart, element.dcpFirst), Math.Min(dcpEnd, element.dcpLim));

833ddcpOld = Math.Min(ddcpOld, (LastFormatCch - dcpStart) + 1); 834ddcpNew = Math.Min(ddcpNew, (Cch - dcpStart) + 1);

80_rect.du = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.du); 81_rect.dv = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.dv);

390double elementWidth = TextDpi.FromTextDpi(Math.Max(1, durAvailable - (mbp.MBPLeft + mbp.MBPRight))); 407elementHeight = Math.Max(TextDpi.FromTextDpi(1), elementHeight - TextDpi.FromTextDpi(mbp.MBPTop + mbp.MBPBottom)); 428elementHeight = Math.Max(TextDpi.FromTextDpi(1), elementHeight);

563offset = Math.Min(_dcp + this.Length, offset);

217return Math.Max(TextDpi.MinWidth, Math.Min(TextDpi.MaxWidth, lineHeight));

187lineAdvance = Math.Max(lineAdvance, _lineHeight); 219lineAdvance = Math.Max(lineAdvance, _lineHeight);

89Math.Min(dcp, _content.Length)

54return (int)Math.Round(d * _scale); 167pageMargin.Right = Math.Max(0.0, pageSize.Width - pageMargin.Left - _minSize); 176pageMargin.Bottom = Math.Max(0.0, pageSize.Height - pageMargin.Top - _minSize);;

190uint itemCount = Math.Min((uint)items.Length, (uint)_list.Count - startIndex);

2371if (Math.Abs(diff) == 1)

362return Math.Max(0, this.OwningGrid.RowDefinitions.Count - 1);

217return Math.Min(100.0, (double)(owner.ViewportWidth * 100.0 / owner.ExtentWidth)); 231return Math.Min(100.0, (double)(owner.ViewportHeight * 100.0 / owner.ExtentHeight)); 267return Math.Min(100.0, (double)(viewport * 100.0 / extent));

234Size childConstraint = new Size(Math.Max(0.0, constraint.Width - combined.Width), 235Math.Max(0.0, constraint.Height - combined.Height)); 639Math.Max(0.0, rt.Width - thick.Left - thick.Right), 640Math.Max(0.0, rt.Height - thick.Top - thick.Bottom)); 983LeftTop = Math.Max(0.0, radii.TopLeft - left); 984TopLeft = Math.Max(0.0, radii.TopLeft - top); 985TopRight = Math.Max(0.0, radii.TopRight - top); 986RightTop = Math.Max(0.0, radii.TopRight - right); 987RightBottom = Math.Max(0.0, radii.BottomRight - right); 988BottomRight = Math.Max(0.0, radii.BottomRight - bottom); 989BottomLeft = Math.Max(0.0, radii.BottomLeft - bottom); 990LeftBottom = Math.Max(0.0, radii.BottomLeft - left);

646PrivateSetCapacity(Math.Max(_items.Length * 2, c_defaultCapacity));

2650indexToSelect = Math.Min(Items.Count - numSelected - 1, indexToSelect); 5073int newRowCount = Math.Abs(endIndex - startIndex) + 1; 5074int newColumnCount = Math.Abs(endColumnIndex - startColumnIndex) + 1; 5092int previousStartIndex = Math.Min(startIndex, currentCellIndex); 5093int previousRowCount = Math.Abs(currentCellIndex - startIndex) + 1; 5094int previousStartColumnIndex = Math.Min(startColumnIndex, currentCellColumnIndex); 5095int previousColumnCount = Math.Abs(currentCellColumnIndex - startColumnIndex) + 1; 5135_selectedCells.AddRegion(Math.Min(startIndex, endIndex), Math.Min(startColumnIndex, endColumnIndex), newRowCount, newColumnCount); 5733nextDisplayIndex = Math.Max(0, InternalColumns.LastVisibleDisplayIndex); 5814nextRowIndex = Math.Max(0, Items.Count - 1); 5999index = Math.Max(0, Math.Min(numItems - 1, index + (shiftModifier ? -1 : 1))); 6142int jumpDistance = Math.Max(1, (int)scrollHost.ViewportHeight - 1); 6144targetIndex = Math.Max(0, Math.Min(targetIndex, Items.Count - 1)); 6587distance = Math.Abs(pt.Y - cellBounds.Top); 6595distance = Math.Abs(pt.X - cellBounds.Left);

190measureHeight = Math.Max(measureHeight, blockMeasureSize.Height); 402measureSize.Height = Math.Max(measureSize.Height, childSize.Height); 422measureSize.Height = Math.Max(measureSize.Height, headerSize.Height); 617measureHeight = Math.Max(measureHeight, childSize.Height); 1908childMeasureWidth = Math.Max(averageColumnWidth, column.MinWidth); 1909childMeasureWidth = Math.Min(childMeasureWidth, column.MaxWidth);

754int columnCount = Math.Min(newFrozenCount, Count); 762int columnCount = Math.Min(oldFrozenCount, Count); 952availableStarSpace = Math.Max(0.0, availableStarSpace - columnMinWidth); 1236double displayValue = Math.Max(width.DesiredValue, minWidth); 1276double displayValue = Math.Min(width.DesiredValue, maxWidth); 1344TakeAwayWidthFromColumns(null, Math.Abs(availableSpaceChange), false, newTotalAvailableSpace); 1368column.SetWidthInternal(new DataGridLength(width.Value, width.UnitType, width.DesiredValue, Math.Min(width.DesiredValue, maxWidth))); 1390Math.Max(width.DisplayValue - nonRetrievableSpace, changedColumn.MinWidth))); 1462return Math.Max(availableSpace - requiredSpace, 0.0); 1673column.UpdateWidthForStarColumn(Math.Max(columnDesiredWidth, column.MinWidth), columnDesiredWidth, columnDesiredWidth / perStarWidth); 1702double columnExcessWidth = onlyShrinkToDesiredWidth ? width.DisplayValue - Math.Max(width.DesiredValue, column.MinWidth) : width.DisplayValue - column.MinWidth; 1787double maxColumnResizeWidth = expandBeyondDesiredWidth ? column.MaxWidth : Math.Min(width.DesiredValue, column.MaxWidth); 1922column.UpdateWidthForStarColumn(Math.Min(columnDesiredWidth, column.MaxWidth), columnDesiredWidth, columnDesiredWidth / perStarWidth); 2009double usedStarSpace = ComputeStarColumnWidths(Math.Min(expectedStarSpace, sumOfStarMaxWidths)); 2010giveAwayWidth = Math.Max(usedStarSpace - expectedStarSpace, 0.0); 2080double lagWidth = Math.Min(width.DesiredValue, columnMaxWidth) - width.DisplayValue; 2111if (DoubleUtil.LessThan(width.DisplayValue, Math.Min(width.DesiredValue, column.MaxWidth))) 2139giveAwayWidth -= Math.Min(contributingSpace, giveAwayWidth); 2146giveAwayWidth = Math.Min(giveAwayWidth, Math.Max(0d, totalSpace - usedSpace)); 2193return Math.Min(usedSpace - totalAvailableWidth, takeAwayWidth); 2201takeAwayWidth = Math.Max(0.0, takeAwayWidth - unusedSpace); 2272double usedStarSpace = ComputeStarColumnWidths(Math.Max(expectedStarSpace, sumOfStarMinWidths)); 2273takeAwayWidth = Math.Max(usedStarSpace - expectedStarSpace, 0.0);

39return new Size(size.Width, Math.Max(0.0, size.Height - thickness)); 43return new Size(Math.Max(0.0, size.Width - thickness), size.Height); 722value = Math.Max(value, minValue); 723value = Math.Min(value, maxValue);

553double minHeight = Math.Max(RowHeader.DesiredSize.Height, MinHeight);

133_minSize = Math.Max(_minSize, minSize); 883sharedMinSize = Math.Max(sharedMinSize, _registry[i]._minSize);

226childConstraint = new Size(Math.Max(0.0, constraint.Width - accumulatedWidth), 227Math.Max(0.0, constraint.Height - accumulatedHeight)); 247parentHeight = Math.Max(parentHeight, accumulatedHeight + childDesiredSize.Height); 253parentWidth = Math.Max(parentWidth, accumulatedWidth + childDesiredSize.Width); 260parentWidth = Math.Max(parentWidth, accumulatedWidth); 261parentHeight = Math.Max(parentHeight, accumulatedHeight); 291Math.Max(0.0, arrangeSize.Width - (accumulatedLeft + accumulatedRight)), 292Math.Max(0.0, arrangeSize.Height - (accumulatedTop + accumulatedBottom)) ); 305rcChild.X = Math.Max(0.0, arrangeSize.Width - accumulatedRight); 316rcChild.Y = Math.Max(0.0, arrangeSize.Height - accumulatedBottom);

1408VerticalOffset = Math.Max(verticalOffset, 0.0); 1409HorizontalOffset = Math.Max(horizontalOffset, 0.0);

722SetCurrentValueInternal(ZoomProperty, Math.Min(Zoom + ZoomIncrement, MaxZoom)); 734SetCurrentValueInternal(ZoomProperty, Math.Max(Zoom - ZoomIncrement, MinZoom));

592Math.Max(ia.OriginWidth, pagePadding.Left), 593Math.Max(ia.OriginHeight, pagePadding.Top), 594Math.Max(ia.MediaSizeWidth - (ia.OriginWidth + ia.ExtentWidth), pagePadding.Right), 595Math.Max(ia.MediaSizeHeight - (ia.OriginHeight + ia.ExtentHeight), pagePadding.Bottom)); 634Zoom = Math.Min(Zoom + ZoomIncrement, MaxZoom); 646Zoom = Math.Max(Zoom - ZoomIncrement, MinZoom); 712SetCurrentValueInternal(ZoomProperty, Math.Min(Zoom + ZoomIncrement, MaxZoom)); 716SetCurrentValueInternal(ZoomProperty, Math.Max(Zoom - ZoomIncrement, MinZoom));

380gridDesiredSize.Width = Math.Max(gridDesiredSize.Width, child.DesiredSize.Width); 381gridDesiredSize.Height = Math.Max(gridDesiredSize.Height, child.DesiredSize.Height); 917cell.ColumnIndex = Math.Min(GetColumn(child), DefinitionsU.Length - 1); 920cell.RowIndex = Math.Min(GetRow(child), DefinitionsV.Length - 1); 925cell.ColumnSpan = Math.Min(GetColumnSpan(child), DefinitionsU.Length - cell.ColumnIndex); 929cell.RowSpan = Math.Min(GetRowSpan(child), DefinitionsV.Length - cell.RowIndex); 1106userMinSize = Math.Max(userMinSize, Math.Min(userSize, userMaxSize)); 1130definitions[i].MeasureSize = Math.Max(userMinSize, Math.Min(userSize, userMaxSize)); 1230DefinitionsU[PrivateCells[i].ColumnIndex].UpdateMinSize(Math.Min(children[i].DesiredSize.Width, DefinitionsU[PrivateCells[i].ColumnIndex].UserMaxSize)); 1247DefinitionsV[PrivateCells[i].RowIndex].UpdateMinSize(Math.Min(children[i].DesiredSize.Height, DefinitionsV[PrivateCells[i].RowIndex].UserMaxSize)); 1468double maxSize = Math.Max(definitions[i].UserMaxSize, minSize); 1520double newMinSize = Math.Min(sizeToDistribute / (count - i), tempDefinitions[i].PreferredSize); 1550tempDefinitions[i].UpdateMinSize(Math.Min(newMinSize, tempDefinitions[i].SizeCache)); 1561tempDefinitions[i].UpdateMinSize(Math.Min(newMinSize, tempDefinitions[i].SizeCache)); 1672starValue = Math.Min(starValue, c_starClip); 1676double maxSize = Math.Max(definitions[i].MinSize, definitions[i].UserMaxSize); 1677maxSize = Math.Min(maxSize, c_starClip); 1715double userSize = Math.Max(availableSize - takenSize, 0.0) * (starValue / tempDefinitions[i].SizeCache); 1716resolvedSize = Math.Min(userSize, tempDefinitions[i].UserMaxSize); 1717resolvedSize = Math.Max(tempDefinitions[i].MinSize, resolvedSize); 1778double power = Math.Floor(Math.Log(Double.MaxValue / maxStar / starCount, 2.0)); 1781scale = Math.Pow(2.0, power - 4.0); // -4 is just for paranoia 1829double effectiveMaxSize = Math.Max(def.MinSize, def.UserMaxSize); 1901resolvedSize = Math.Max(resolvedDef.MinSize, resolvedDef.UserMaxSize); 2019double resolvedSize = (def.MeasureSize > 0.0) ? Math.Max(availableSize - takenSize, 0.0) * (def.MeasureSize / def.SizeCache) : 0.0; 2022resolvedSize = Math.Min(resolvedSize, def.UserMaxSize); 2023resolvedSize = Math.Max(def.MinSize, resolvedSize); 2112starValue = Math.Min(starValue, c_starClip); 2116double maxSize = Math.Max(definitions[i].MinSizeForArrange, definitions[i].UserMaxSize); 2117maxSize = Math.Min(maxSize, c_starClip); 2157definitions[i].SizeCache = Math.Max(definitions[i].MinSizeForArrange, Math.Min(userSize, userMaxSize)); 2202double userSize = Math.Max(finalSize - allPreferredArrangeSize, 0.0) * (starValue / definitions[definitionIndices[i]].SizeCache); 2203resolvedSize = Math.Min(userSize, definitions[definitionIndices[i]].UserMaxSize); 2204resolvedSize = Math.Max(definitions[definitionIndices[i]].MinSizeForArrange, resolvedSize); 2229final = Math.Max(final, definitions[definitionIndex].MinSizeForArrange); 2230final = Math.Min(final, definitions[definitionIndex].SizeCache); 2236final = Math.Max(final, definitions[definitionIndex].MinSizeForArrange); 2237final = Math.Min(final, definitions[definitionIndex].SizeCache); 2270final = Math.Max(final, definition.MinSizeForArrange); 2286final = Math.Max(final, definition.MinSizeForArrange); 2357double power = Math.Floor(Math.Log(Double.MaxValue / maxStar / starCount, 2.0)); 2360scale = Math.Pow(2.0, power - 4.0); // -4 is just for paranoia 2404double effectiveMaxSize = Math.Max(def.MinSizeForArrange, def.UserMaxSize); 2443def.SizeCache = Math.Max(def.MinSizeForArrange, Math.Min(userSize, userMaxSize)); 2512resolvedSize = Math.Max(resolvedDef.MinSizeForArrange, resolvedDef.UserMaxSize); 2644double resolvedSize = (def.MeasureSize > 0.0) ? Math.Max(finalSize - takenSize, 0.0) * (def.MeasureSize / def.SizeCache) : 0.0; 2647resolvedSize = Math.Min(resolvedSize, def.UserMaxSize); 2648resolvedSize = Math.Max(def.MinSizeForArrange, resolvedSize); 2739final = Math.Max(final, definition.MinSizeForArrange); 2755final = Math.Max(final, definition.MinSizeForArrange); 2797double minPower = Math.Floor(Math.Log(minRatio, 2.0)); 2798double maxPower = Math.Floor(Math.Log(maxRatio, 2.0)); 2799double f = Math.Pow(2.0, Math.Floor((minPower + maxPower) / 2.0)); 2878Array.Clear(extData.TempDefinitions, 0, Math.Max(DefinitionsU.Length, DefinitionsV.Length)); 3083int requiredLength = Math.Max(DefinitionsU.Length, DefinitionsV.Length) * 2; 3116int requiredLength = Math.Max(Math.Max(DefinitionsU.Length, DefinitionsV.Length), 1) * 2; 3134int requiredLength = Math.Max(DefinitionsU.Length, DefinitionsV.Length); 3226return (Math.Abs(d) < c_epsilon); 3237return (Math.Abs(d1 - d2) < c_epsilon);

504_resizeData.SplitterLength = Math.Min(ActualWidth, ActualHeight); 656horizontalChange = Math.Round(horizontalChange / dragIncrement) * dragIncrement; 657verticalChange = Math.Round(verticalChange / dragIncrement) * dragIncrement; 664_resizeData.Adorner.OffsetX = Math.Min(Math.Max(horizontalChange, _resizeData.MinChange), _resizeData.MaxChange); 668_resizeData.Adorner.OffsetY = Math.Min(Math.Max(verticalChange, _resizeData.MinChange), _resizeData.MaxChange); 802definition1Min = Math.Max(definition1Min, _resizeData.SplitterLength); 806definition2Min = Math.Max(definition2Min, _resizeData.SplitterLength); 812minDelta = -Math.Min(definition1Len - definition1Min, definition2Max - definition2Len); 813maxDelta = Math.Min(definition1Max - definition1Len, definition2Len - definition2Min); 921delta = Math.Min(Math.Max(delta, min), max);

262double childConstraintWidth = Math.Max(0.0, constraint.Width - accumulatedWidth); 284childConstraintWidth = Math.Min(childConstraintWidth, column.DesiredWidth); 292childConstraintWidth = Math.Min(childConstraintWidth, column.Width); 299maxHeight = Math.Max(maxHeight, child.DesiredSize.Height); 306maxHeight = Math.Max(maxHeight, _paddingHeader.DesiredSize.Height); 355double childArrangeWidth = Math.Min(remainingWidth, ((column.State == ColumnMeasureState.SpecificWidth) ? column.Width : column.DesiredWidth)); 389rect = new Rect(accumulatedWidth, 0.0, Math.Max(remainingWidth, 0.0), arrangeSize.Height); 1247return (DoubleUtil.GreaterThan(Math.Abs(currentPos.X - originalPos.X), c_thresholdX));

148double childConstraintWidth = Math.Max(0.0, constraint.Width - accumulatedWidth); 177childConstraintWidth = Math.Min(childConstraintWidth, column.DesiredWidth); 185childConstraintWidth = Math.Min(childConstraintWidth, column.Width); 192maxHeight = Math.Max(maxHeight, child.DesiredSize.Height); 225double childArrangeWidth = Math.Min(remainingWidth, ((column.State == ColumnMeasureState.SpecificWidth) ? column.Width : column.DesiredWidth));

177newSize.Width = Math.Max(newSize.Width, sizeStrokes.Width); 178newSize.Height = Math.Max(newSize.Height, sizeStrokes.Height); 211availableSize = new Size(Math.Min(arrangeSize.Width, _constraintSize.Width), 212Math.Min(arrangeSize.Height, _constraintSize.Height));

2764int index = Math.Min(oldIndex, newIndex);

2811return FindFocusable((int)(ScrollHost.VerticalOffset + Math.Max(ScrollHost.ViewportHeight - 1, 0)), 2825return FindFocusable((int)(ScrollHost.HorizontalOffset + Math.Max(ScrollHost.ViewportWidth - 1, 0)),

90double percent = Math.Min(100.0, Math.Max(0.0, (verticalOffset * 100.0 / (extentHeight - viewportHeight))));

200finalCount = Math.Min(count, _container.SymbolCount - _offset); 204finalCount = Math.Min(count, _offset);

1615Debug.Assert(((int)pt.X == (int)Math.Round(pt2.X)) && ((int)pt.Y == (int)Math.Round(pt2.Y)), "got incorrect mouse point");

258contentConstraint.Width = Math.Max(0.0, contentConstraint.Width - bulletSize.Width); 264Size desiredSize = new Size(bulletSize.Width + contentSize.Width, Math.Max(bulletSize.Height, contentSize.Height)); 300contentSize.Width = Math.Max(content.DesiredSize.Width, arrangeSize.Width - bullet.DesiredSize.Width); 301contentSize.Height = Math.Max(content.DesiredSize.Height, arrangeSize.Height); 306bulletOffsetY += Math.Max(0d, centerY - bulletSize.Height * 0.5d);

134dirtyCount = Math.Min(newColumnCount, oldColumnCount);

122desiredSize.Width = Math.Max(desiredSize.Width, indicatorSize.Width); 123desiredSize.Height = Math.Max(desiredSize.Height, indicatorSize.Height); 130desiredSize.Width = Math.Max(desiredSize.Width, indicatorSize.Width); 131desiredSize.Height = Math.Max(desiredSize.Height, indicatorSize.Height); 134desiredSize.Width = Math.Min(availableSize.Width, desiredSize.Width); 154childRect.Width = Math.Max(finalSize.Width, dataGrid.CellsPanelActualWidth); 649return DoubleUtil.GreaterThan(Math.Abs(currentPos.X - originalPos.X), SystemParameters.MinimumHorizontalDragDistance); 698height = Math.Max(_draggingSrcColumnHeader.RenderSize.Height, _columnHeaderDragIndicator.Height); 922columnEstimatedWidth = Math.Max(averageColumnWidth, column.MinWidth); 923columnEstimatedWidth = Math.Min(columnEstimatedWidth, column.MaxWidth);

962pageVisualRect.Width = Math.Min(pageVisualRect.Width, maxWidth); 963pageVisualRect.Height = Math.Min(pageVisualRect.Height, maxHeight);

2109if (Math.Abs(score - childArea) < Tolerance) 2135if (Math.Abs(intersection.Width - childBounds.Width) > Tolerance || 2136Math.Abs(intersection.Height - childBounds.Height) > Tolerance) 2150if (!IsTransparent || double.IsNaN(horizontalAxis.Y) || Math.Abs(horizontalAxis.Y) < Tolerance) 2162else if (IsTransparent && Math.Abs(horizontalAxis.X) < Tolerance) 2185if (!IsTransparent || double.IsNaN(verticalAxis.X) || Math.Abs(verticalAxis.X) < Tolerance) 2196else if (IsTransparent && Math.Abs(verticalAxis.Y) < Tolerance) 2251if (!IsTransparent || double.IsNaN(verticalAxis.X) || Math.Abs(verticalAxis.X) < Tolerance) 2253limitSize.Height = Math.Max(0.0, Math.Max(screenBounds.Bottom - targetBounds.Bottom, targetBounds.Top - screenBounds.Top)); 2255else if (IsTransparent && Math.Abs(verticalAxis.Y) < Tolerance) 2257limitSize.Width = Math.Max(0.0, Math.Max(screenBounds.Right - targetBounds.Right, targetBounds.Left - screenBounds.Left)); 2273if (!IsTransparent || double.IsNaN(horizontalAxis.X) || Math.Abs(horizontalAxis.Y) < Tolerance) 2275limitSize.Width = Math.Max(0.0, Math.Max(screenBounds.Right - targetBounds.Right, targetBounds.Left - screenBounds.Left)); 2277else if (IsTransparent && Math.Abs(horizontalAxis.X) < Tolerance) 2279limitSize.Height = Math.Max(0.0, Math.Max(screenBounds.Bottom - targetBounds.Bottom, targetBounds.Top - screenBounds.Top)); 2629desiredSize.Width = Math.Min(desiredSize.Width, screenBounds.Width); 2630desiredSize.Width = Math.Min(desiredSize.Width, limitSize.Width); 2634desiredSize.Height = Math.Min(desiredSize.Height, screenBounds.Height); 2635desiredSize.Height = Math.Min(desiredSize.Height, maxHeight); 2636desiredSize.Height = Math.Min(desiredSize.Height, limitSize.Height); 2708return new Rect(mousePoint.x, mousePoint.y - 1, Math.Max(0, cursorWidth - hotX), Math.Max(0, cursorHeight - hotY + 2));

227restrictWidth = Math.Abs(restrictedSize.Width - desiredSize.Width) > Popup.Tolerance; 228restrictHeight = Math.Abs(restrictedSize.Height - desiredSize.Height) > Popup.Tolerance; 239return new Size(Math.Min(restrictedSize.Width, restricted2DDesiredSize.Width), 240Math.Min(restrictedSize.Height, restricted2DDesiredSize.Height));

349perpendicularDragDelta = Math.Abs(verticalDragDelta); 353perpendicularDragDelta = Math.Abs(horizontalDragDelta); 425newValue = Math.Min(Math.Max(newValue, Minimum), Maximum); 555double newValue = Math.Max(Value - SmallChange, Minimum); 564double newValue = Math.Min(Value + SmallChange, Maximum); 573double newValue = Math.Max(Value - LargeChange, Minimum); 582double newValue = Math.Min(Value + LargeChange, Maximum);

445desiredSize.Width = Math.Min(constraint.Width, desiredSize.Width); 446desiredSize.Height = Math.Min(constraint.Height, desiredSize.Height); 494childRect.Width = Math.Max(childRect.Width, arrangeSize.Width); 495childRect.Height = Math.Max(childRect.Height, arrangeSize.Height); 697return Math.Max(0.0, offset);

212desiredSizeWithoutMargin.Height = Math.Max(0d, element.DesiredSize.Height - margin.Top - margin.Bottom); 213desiredSizeWithoutMargin.Width = Math.Max(0d, element.DesiredSize.Width - margin.Left - margin.Right); 284childSize.Height = Math.Max(0d, childSize.Height - topOffset - bottomOffset); 285childSize.Width = Math.Max(0d, childSize.Width - leftOffset - rightOffset); 416currentAverageGap = Math.Max(0d, (rowWidthLimit - currentRowWidth) / numberOfHeadersInCurrentRow); // The amout of width that should be added to justify the header

535Point pt2 = new Point(startPoint.X + tickLen2, y0 + Math.Abs(tickLen2) * progression); 548pt2 = new Point(startPoint.X + tickLen2, y0 - Math.Abs(tickLen2) * progression); 640Point pt2 = new Point(x0 + Math.Abs(tickLen2) * progression, startPoint.Y + tickLen2); 653pt2 = new Point(x0 - Math.Abs(tickLen2) * progression, startPoint.Y + tickLen2);

122_wrapWidth = Math.Min(_wrapWidth, constraint.Width); 131_panelSize.Width = Math.Max(curLineSize.Width, _panelSize.Width); 137_panelSize.Width = Math.Max(sz.Width, _panelSize.Width); 145curLineSize.Height = Math.Max(sz.Height, curLineSize.Height); 150_panelSize.Width = Math.Max(curLineSize.Width, _panelSize.Width); 166_wrapWidth = Math.Min(_wrapWidth, arrangeBounds.Width); 186curLineSize.Height = Math.Max(sz.Height, curLineSize.Height);

125panelDesiredSize.Height = Math.Max(panelDesiredSize.Height, childDesiredSize.Height); 129panelDesiredSize.Width = Math.Max(panelDesiredSize.Width, childDesiredSize.Width); 184panelDesiredSize.Height = Math.Max(panelDesiredSize.Height, childDesiredSize.Height); 189panelDesiredSize.Width = Math.Max(panelDesiredSize.Width, childDesiredSize.Width); 313rcChild.Height = Math.Max(arrangeSize.Height, child.DesiredSize.Height); 320rcChild.Width = Math.Max(arrangeSize.Width, child.DesiredSize.Width);

82return Math.Max(Minimum, Math.Min(Maximum, val)); 482double viewportSize = Math.Max(0.0, ViewportSize); 581double range = Math.Max(0.0, Maximum - min); 582double offset = Math.Min(range, Value - min); 620double range = Math.Max(0.0, Maximum - min); 621double offset = Math.Min(range, Value - min); 625double extent = Math.Max(0.0, range) + viewportSize; 637thumbMinLength = Math.Floor(buttonHeight * 0.5); 645thumbMinLength = Math.Floor(buttonWidth * 0.5); 651thumbLength = Math.Max(thumbMinLength, thumbLength);

297_rows = (int)Math.Sqrt(nonCollapsedCount);

308dlg.MinPage = Math.Max(1, Math.Min(_minPage, _maxPage)); 309dlg.MaxPage = Math.Max(dlg.MinPage, Math.Max(_minPage, _maxPage)); 315Math.Max((int)dlg.MinPage, _pageRange.PageFrom), 316Math.Min((int)dlg.MaxPage, _pageRange.PageTo));

646PrivateSetCapacity(Math.Max(_items.Length * 2, c_defaultCapacity));

409get { return Math.Max(0.0, ExtentWidth - ViewportWidth); } 417get { return Math.Max(0.0, ExtentHeight - ViewportHeight); } 1757DoubleUtil.LessThan(Math.Abs(unusedX), PanningInfo.PreFeedbackTranslationX)) 1765DoubleUtil.LessThan(Math.Abs(unusedY), PanningInfo.PreFeedbackTranslationY)) 1810double newUnused = Math.Max(unused + delta, 0); 1819double newUnused = Math.Min(unused + delta, 0); 1830Math.Round(PanningRatio * cumulativeTranslation / _panningInfo.DeltaPerHorizontalOffet)); 1840Math.Round(PanningRatio * cumulativeTranslation / _panningInfo.DeltaPerVerticalOffset)); 1853if (Math.Abs(Environment.TickCount - _panningInfo.InertiaBoundaryBeginTimestamp) < PanningInfo.InertiaBoundryMinimumTicks) 1858return (DoubleUtil.GreaterThanOrClose(Math.Abs(_panningInfo.UnusedTranslation.X), PanningInfo.MaxInertiaBoundaryTranslation) || 1859DoubleUtil.GreaterThanOrClose(Math.Abs(_panningInfo.UnusedTranslation.Y), PanningInfo.MaxInertiaBoundaryTranslation)); 1878bool validX = (DoubleUtil.GreaterThan(Math.Abs(translation.X), PanningInfo.PrePanTranslation)); 1879bool validY = (DoubleUtil.GreaterThan(Math.Abs(translation.Y), PanningInfo.PrePanTranslation)); 1889bool biggerX = (DoubleUtil.GreaterThanOrClose(Math.Abs(translation.X), Math.Abs(translation.Y))); 1902bool biggerY = (DoubleUtil.GreaterThanOrClose(Math.Abs(translation.Y), Math.Abs(translation.X)));

704Math.Max(ia.OriginWidth, pagePadding.Left), 705Math.Max(ia.OriginHeight, pagePadding.Top), 706Math.Max(ia.MediaSizeWidth - (ia.OriginWidth + ia.ExtentWidth), pagePadding.Right), 707Math.Max(ia.MediaSizeHeight - (ia.OriginHeight + ia.ExtentHeight), pagePadding.Bottom)); 745SetCurrentValueInternal(ZoomProperty, Math.Min(Zoom + ZoomIncrement, MaxZoom)); 757SetCurrentValueInternal(ZoomProperty, Math.Max(Zoom - ZoomIncrement, MinZoom));

1018valueToSize = Math.Max(0.0, (trackSize.Width - thumbSize.Width) / range); 1024Canvas.SetLeft(rangeElement, (thumbSize.Width * 0.5) + Math.Max(Maximum - SelectionEnd, 0) * valueToSize); 1028Canvas.SetLeft(rangeElement, (thumbSize.Width * 0.5) + Math.Max(SelectionStart - Minimum, 0) * valueToSize); 1040valueToSize = Math.Max(0.0, (trackSize.Height - thumbSize.Height) / range); 1046Canvas.SetTop(rangeElement, (thumbSize.Height * 0.5) + Math.Max(SelectionStart - Minimum, 0) * valueToSize); 1050Canvas.SetTop(rangeElement, (thumbSize.Height * 0.5) + Math.Max(Maximum - SelectionEnd,0) * valueToSize); 1083valueToSize = Math.Max(0.0, (trackSize.Width - thumbSize.Width) / range); 1107valueToSize = Math.Max(0.0, (trackSize.Height - thumbSize.Height) / range); 1215previous = Minimum + (Math.Round(((value - Minimum) / TickFrequency)) * TickFrequency); 1216next = Math.Min(Maximum, previous + TickFrequency); 1236double next = SnapToTick(Math.Max(this.Minimum, Math.Min(this.Maximum, value + direction))); 1274double tickNumber = Math.Round((value - Minimum) / TickFrequency); 1435this.SetCurrentValueInternal(ValueProperty, Math.Max(this.Minimum, Math.Min(this.Maximum, snappedValue)));

604stackDesiredSize.Height = Math.Max(stackDesiredSize.Height, childDesiredSize.Height); 609stackDesiredSize.Width = Math.Max(stackDesiredSize.Width, childDesiredSize.Width); 669offset.Y = Math.Max(0, Math.Min(offset.Y, extent.Height - viewport.Height)); 677offset.X = Math.Max(0, Math.Min(offset.X, extent.Width - viewport.Width)); 682stackDesiredSize.Width = Math.Min(stackDesiredSize.Width, constraint.Width); 683stackDesiredSize.Height = Math.Min(stackDesiredSize.Height, constraint.Height); 761rcChild.Height = Math.Max(arrangeSize.Height, child.DesiredSize.Height); 768rcChild.Width = Math.Max(arrangeSize.Width, child.DesiredSize.Width); 902double left = Math.Max(targetRectOffset, minPhysicalOffset); 903targetRectSize = Math.Max(Math.Min(targetRectSize + targetRectOffset, minPhysicalOffset + viewportSize) - left, 0); 1001iNewOffset = Math.Max(Math.Min(numberOfItems - 1, iNewOffset), 0);

1150horizontalChange = Math.Min(Math.Max(minBoundary.X, horizontalChange), maxBoundary.X); 1151verticalChange = Math.Min(Math.Max(minBoundary.Y, verticalChange), maxBoundary.Y);

1275Size contentSize = new Size(Math.Max(0.0, constraint.Width - (padding.Left + padding.Right)), 1276Math.Max(0.0, constraint.Height - (padding.Top + padding.Bottom))); 1315desiredSize.Width = Math.Max(desiredSize.Width, line.GetCollapsedWidth()); 1541double contentBottom = Math.Max(0.0, RenderSize.Height - Padding.Bottom); 1978Size contentSize = new Size(Math.Max(0.0, _referenceSize.Width - (padding.Left + padding.Right)), 1979Math.Max(0.0, _referenceSize.Height - (padding.Top + padding.Bottom))); 2331int dcpStart = Math.Max(dcpLineStart, dcpPositionStart); 2332int dcpEnd = Math.Min(dcpLineEnd, dcpPositionEnd); 3116Size contentSize = new Size(Math.Max(0.0, computedSize.Width - (padding.Left + padding.Right)), 3117Math.Max(0.0, computedSize.Height - (padding.Top + padding.Bottom))); 3166double contentBottom = Math.Max(0.0, RenderSize.Height - Padding.Bottom); 3196width = Math.Max(0.0, width - paddingWidth);

333return (int)Math.Floor((this.VerticalOffset / lineHeight) + epsilon); 357return (int)Math.Floor((this.VerticalOffset + this.ViewportHeight - 1) / GetLineHeight()); 1729if ( 2*(prefix + suffix) >= Math.Min(oldText.Length, newText.Length))

995int absCount = (count == int.MinValue) ? int.MaxValue : Math.Abs(count);

558extraLength = Math.Max(0.0, desiredSize.Width - toolBarPanel.DesiredSize.Width + margin.Left + margin.Right); 562extraLength = Math.Max(0.0, desiredSize.Height - toolBarPanel.DesiredSize.Height + margin.Top + margin.Bottom);

389bandThickness = Math.Max(bandThickness, fHorizontal ? toolBar.DesiredSize.Height : toolBar.DesiredSize.Width); 404toolBarTrayDesiredSize.Width = Math.Max(toolBarTrayDesiredSize.Width, bandLength); 409toolBarTrayDesiredSize.Height = Math.Max(toolBarTrayDesiredSize.Height, bandLength); 800currentToolBar.Width = Math.Max(currentToolBar.MinLength, currentToolBar.RenderSize.Width - toolBarOffset + position); 802currentToolBar.Height = Math.Max(currentToolBar.MinLength, currentToolBar.RenderSize.Height - toolBarOffset + position);

613int left = Math.Max(Left, region.Left); 614int top = Math.Max(Top, region.Top); 615int right = Math.Min(Right, region.Right); 616int bottom = Math.Min(Bottom, region.Bottom); 686Left = Math.Min(Left, region.Left); 687Top = Math.Min(Top, region.Top); 688Right = Math.Max(prevRight, region.Right); 689Bottom = Math.Max(prevBottom, region.Bottom); 729int top = Math.Max(Top, region.Top); 730int bottom = Math.Min(Bottom, region.Bottom); 737int top = Math.Max(Top, region.Top); 738int bottom = Math.Min(Bottom, region.Bottom);

516double delta = Math.Abs(scrollX - oldViewportOffset.X); 529_scrollData._offset.X = Math.Floor(_scrollData._offset.X); 530_scrollData._computedOffset.X = Math.Floor(_scrollData._computedOffset.X); 644double delta = Math.Abs(scrollY - oldViewportOffset.Y); 657_scrollData._offset.Y = Math.Floor(_scrollData._offset.Y); 658_scrollData._computedOffset.Y = Math.Floor(_scrollData._computedOffset.Y); 2336double factor = Math.Min(1.0, isHorizontal ? viewport.Width / extendedViewport.Width : viewport.Height / extendedViewport.Height); 2337int calcItemsInViewportCount = (int)Math.Ceiling(factor * _itemsInExtendedViewportCount); 2338excludeCount = Math.Max(excludeCount, 2632double spanBeforeViewport = Math.Max(isHorizontal ? viewport.X : viewport.Y, 0.0); 2689_firstItemInExtendedViewportIndex = Math.Max(_firstItemInExtendedViewportIndex - 1, 0); 2691_firstItemInExtendedViewportChildIndex = Math.Max(_firstItemInExtendedViewportChildIndex, 0); 3389arrangeLength = Math.Max(isHorizontal ? arrangeSize.Height : arrangeSize.Width, arrangeLength); 4767pixelSizeBeforeViewport = Math.Max(pixelSizeBeforeViewport, Math.Abs(_viewport.X - _extendedViewport.X)); 4771logicalSizeBeforeViewport = Math.Max(logicalSizeBeforeViewport, Math.Abs(_viewport.X - _extendedViewport.X)); 4803extendedViewport.Width = Math.Max(extendedViewport.Width + extendedViewport.X, 0.0); 4814extendedViewport.Width = Math.Max(_scrollData._extent.Width - extendedViewport.X, 0.0); 4843extendedViewport.Width = Math.Max(extendedViewport.Width / approxSizeOfLogicalUnit + extendedViewport.X, 0.0) * approxSizeOfLogicalUnit; 4854extendedViewport.Width = Math.Max(_scrollData._extent.Width - extendedViewport.X, 0.0) * approxSizeOfLogicalUnit; 4883pixelSizeBeforeViewport = Math.Max(pixelSizeBeforeViewport, Math.Abs(_viewport.Y - _extendedViewport.Y)); 4887logicalSizeBeforeViewport = Math.Max(logicalSizeBeforeViewport, Math.Abs(_viewport.Y - _extendedViewport.Y)); 4919extendedViewport.Height = Math.Max(extendedViewport.Height + extendedViewport.Y, 0.0); 4930extendedViewport.Height = Math.Max(_scrollData._extent.Height - extendedViewport.Y, 0.0); 4959extendedViewport.Height = Math.Max(extendedViewport.Height / approxSizeOfLogicalUnit + extendedViewport.Y, 0.0) * approxSizeOfLogicalUnit; 4970extendedViewport.Height = Math.Max(_scrollData._extent.Height - extendedViewport.Y, 0.0) * approxSizeOfLogicalUnit; 4982double factor = Math.Max(1.0, isHorizontal ? extendedViewport.Width / viewport.Width : extendedViewport.Height / viewport.Height); 4983int calcItemsInExtendedViewportCount = (int)Math.Ceiling(factor * _actualItemsInExtendedViewportCount); 4984itemsInExtendedViewportCount = Math.Max(calcItemsInExtendedViewportCount, itemsInExtendedViewportCount); 5095viewport.Width = Math.Max(viewport.Width - sizeAfterStartViewportEdge, 0); 5099cacheBeforeSize = Math.Max(cacheBeforeSize - sizeBeforeStartViewportEdge, 0); 5103cacheBeforeSize = Math.Max(cacheBeforeSize - Math.Floor(logicalSize.Width * sizeBeforeStartViewportEdge / pixelSize.Width), 0); 5130viewport.Width = Math.Max(0, parentViewport.Width - pixelSize.Width); 5145cacheAfterSize = Math.Max(cacheAfterSize - sizeAfterEndViewportEdge, 0); 5149cacheAfterSize = Math.Max(cacheAfterSize - Math.Floor(logicalSize.Width * sizeAfterEndViewportEdge / pixelSize.Width), 0); 5161cacheAfterSize = Math.Max(cacheAfterSize - pixelSize.Width, 0); 5165cacheAfterSize = Math.Max(cacheAfterSize - logicalSize.Width, 0); 5194viewport.Height = Math.Max(viewport.Height - sizeAfterStartViewportEdge, 0); 5198cacheBeforeSize = Math.Max(cacheBeforeSize - sizeBeforeStartViewportEdge, 0); 5202cacheBeforeSize = Math.Max(cacheBeforeSize - Math.Floor(logicalSize.Height * sizeBeforeStartViewportEdge / pixelSize.Height), 0); 5229viewport.Height = Math.Max(0, parentViewport.Height - pixelSize.Height); 5244cacheAfterSize = Math.Max(cacheAfterSize - sizeAfterEndViewportEdge, 0); 5248cacheAfterSize = Math.Max(cacheAfterSize - Math.Floor(logicalSize.Height * sizeAfterEndViewportEdge / pixelSize.Height), 0); 5260cacheAfterSize = Math.Max(cacheAfterSize - pixelSize.Height, 0); 5264cacheAfterSize = Math.Max(cacheAfterSize - logicalSize.Height, 0); 5329cacheBeforeSize = Math.Max(0, cacheBeforeSize - parentViewport.X); 5334viewport.Width = Math.Max(0, viewport.Width + viewport.X); 5354cacheBeforeSize = Math.Max(0, cacheBeforeSize - inset.Right); 5358cacheBeforeSize = Math.Max(0, cacheBeforeSize - 1); 5373viewport.Width = Math.Max(0, viewport.Width - inset.Left); 5384cacheAfterSize = Math.Max(0, cacheAfterSize - (inset.Left - viewport.Width)); 5401cacheAfterSize = Math.Max(0, cacheAfterSize - inset.Left); 5405cacheAfterSize = Math.Max(0, cacheAfterSize - 1); 5432cacheBeforeSize = Math.Max(0, cacheBeforeSize - parentViewport.Y); 5437viewport.Height = Math.Max(0, viewport.Height + viewport.Y); 5457cacheBeforeSize = Math.Max(0, cacheBeforeSize - inset.Bottom); 5461cacheBeforeSize = Math.Max(0, cacheBeforeSize - 1); 5476viewport.Height = Math.Max(0, viewport.Height - inset.Top); 5487cacheAfterSize = Math.Max(0, cacheAfterSize - (inset.Top - viewport.Height)); 5504cacheAfterSize = Math.Max(0, cacheAfterSize - inset.Top); 5508cacheAfterSize = Math.Max(0, cacheAfterSize - 1); 5564double spanBeforeViewport = Math.Max(isHorizontal ? viewport.X : viewport.Y, 0.0); 5576firstItemInViewportIndex = (int)Math.Floor(spanBeforeViewport / childSize); 6552double eps = (Math.Abs(value1) + Math.Abs(value2)) * Tolerance; 6733childViewport.X = Math.Min(childViewport.X, 0) - 6736childViewport.Width = Math.Max(childViewport.Width - stackPixelSizeInViewport.Width, 0.0); 6741childViewport.Width = Math.Max(childViewport.Width - stackPixelSizeInViewport.Width, 0.0); 6749Math.Max(parentCacheSize.CacheBeforeViewport - stackLogicalSizeInCacheBeforeViewport.Width, 0.0), 6752Math.Max(parentCacheSize.CacheAfterViewport - stackLogicalSizeInCacheAfterViewport.Width, 0.0)); 6760Math.Max(parentCacheSize.CacheBeforeViewport - stackPixelSizeInCacheBeforeViewport.Width, 0.0), 6763Math.Max(parentCacheSize.CacheAfterViewport - stackPixelSizeInCacheAfterViewport.Width, 0.0)); 6778childViewport.Y = Math.Min(childViewport.Y, 0) - 6782childViewport.Height = Math.Max(childViewport.Height - stackPixelSizeInViewport.Height, 0.0); 6787childViewport.Height = Math.Max(childViewport.Height - stackPixelSizeInViewport.Height, 0.0); 6795Math.Max(parentCacheSize.CacheBeforeViewport - stackLogicalSizeInCacheBeforeViewport.Height, 0.0), 6798Math.Max(parentCacheSize.CacheAfterViewport - stackLogicalSizeInCacheAfterViewport.Height, 0.0)); 6806Math.Max(parentCacheSize.CacheBeforeViewport - stackPixelSizeInCacheBeforeViewport.Height, 0.0), 6809Math.Max(parentCacheSize.CacheAfterViewport - stackPixelSizeInCacheAfterViewport.Height, 0.0)); 6914childLogicalSize.Width = Math.Max(itemDesiredSizes.LogicalSize.Width, logicalHeaderSize.Width); 6919childLogicalSize.Height = Math.Max(itemDesiredSizes.LogicalSize.Height, logicalHeaderSize.Height); 7118Size frontPixelSize = isHorizontal ? new Size(Math.Max(inset.Left,0), childDesiredSize.Height) 7119: new Size(childDesiredSize.Width, Math.Max(inset.Top, 0)); 7132Size backPixelSize = isHorizontal ? new Size(Math.Max(inset.Right,0), childDesiredSize.Height) 7133: new Size(childDesiredSize.Width, Math.Max(inset.Bottom,0)); 7146adjustedChildViewport.Width = Math.Max(0, adjustedChildViewport.Width - childPixelSizeInViewport.Width); 7152adjustedChildViewport.Height = Math.Max(0, adjustedChildViewport.Height - childPixelSizeInViewport.Height); 7237pixelSizeBeforeViewport = DoubleUtil.LessThan(childViewport.X, childPixelSize.Width) ? Math.Max(childViewport.X, 0.0) : childPixelSize.Width; 7238pixelSizeInViewport = Math.Min(childViewport.Width, childPixelSize.Width - pixelSizeBeforeViewport); 7239pixelSizeAfterViewport = Math.Max(childPixelSize.Width - pixelSizeInViewport - pixelSizeBeforeViewport, 0.0); // Please note that due to rounding errors this subtraction can lead to negative values. Hence the Math.Max call 7284logicalSizeBeforeViewport = Math.Floor(childLogicalSize.Width * pixelSizeBeforeViewport / childPixelSize.Width); 7285logicalSizeAfterViewport = Math.Floor(childLogicalSize.Width * pixelSizeAfterViewport / childPixelSize.Width); 7293double childPixelHeightInViewport = Math.Min(childViewport.Height, childPixelSize.Height - Math.Max(childViewport.Y, 0.0)); 7296childPixelSizeInViewport.Height = Math.Max(childPixelSizeInViewport.Height, childPixelHeightInViewport); 7298childPixelSizeInCacheBeforeViewport.Height = Math.Max(childPixelSizeInCacheBeforeViewport.Height, childPixelHeightInViewport); 7300childPixelSizeInCacheAfterViewport.Height = Math.Max(childPixelSizeInCacheAfterViewport.Height, childPixelHeightInViewport); 7303childLogicalSizeInViewport.Height = Math.Max(childLogicalSizeInViewport.Height, childLogicalSize.Height); 7305childLogicalSizeInCacheBeforeViewport.Height = Math.Max(childLogicalSizeInCacheBeforeViewport.Height, childLogicalSize.Height); 7307childLogicalSizeInCacheAfterViewport.Height = Math.Max(childLogicalSizeInCacheAfterViewport.Height, childLogicalSize.Height); 7329pixelSizeBeforeViewport = DoubleUtil.LessThan(childViewport.Y, childPixelSize.Height) ? Math.Max(childViewport.Y, 0.0) : childPixelSize.Height; 7330pixelSizeInViewport = Math.Min(childViewport.Height, childPixelSize.Height - pixelSizeBeforeViewport); 7331pixelSizeAfterViewport = Math.Max(childPixelSize.Height - pixelSizeInViewport - pixelSizeBeforeViewport, 0.0); // Please note that due to rounding errors this subtraction can lead to negative values. Hence the Math.Max call 7376logicalSizeBeforeViewport = Math.Floor(childLogicalSize.Height * pixelSizeBeforeViewport / childPixelSize.Height); 7377logicalSizeAfterViewport = Math.Floor(childLogicalSize.Height * pixelSizeAfterViewport / childPixelSize.Height); 7385double childPixelWidthInViewport = Math.Min(childViewport.Width, childPixelSize.Width - Math.Max(childViewport.X, 0.0)); 7388childPixelSizeInViewport.Width = Math.Max(childPixelSizeInViewport.Width, childPixelWidthInViewport); 7390childPixelSizeInCacheBeforeViewport.Width = Math.Max(childPixelSizeInCacheBeforeViewport.Width, childPixelWidthInViewport); 7392childPixelSizeInCacheAfterViewport.Width = Math.Max(childPixelSizeInCacheAfterViewport.Width, childPixelWidthInViewport); 7395childLogicalSizeInViewport.Width = Math.Max(childLogicalSizeInViewport.Width, childLogicalSize.Width); 7397childLogicalSizeInCacheBeforeViewport.Width = Math.Max(childLogicalSizeInCacheBeforeViewport.Width, childLogicalSize.Width); 7399childLogicalSizeInCacheAfterViewport.Width = Math.Max(childLogicalSizeInCacheAfterViewport.Width, childLogicalSize.Width); 7442sz1.Height = Math.Max(sz1.Height, sz2.Height); 7447sz1.Width = Math.Max(sz1.Width, sz2.Width); 7497childSize = new Size(Math.Max(headerDesiredSizes.PixelSize.Width, itemDesiredSizes.PixelSize.Width), 7502childSize = new Size(Math.Max(headerDesiredSizes.LogicalSize.Width, itemDesiredSizes.LogicalSize.Width), 7586uniformOrAverageContainerSize = Math.Round(sumOfContainerSizes / numContainerSizes); 7670Math.Max(1, itemDesiredSizes.LogicalSize.Height)) 7671: new Size(Math.Max(1, itemDesiredSizes.LogicalSize.Width), 7812Math.Max(uniformOrAverageContainerPixelSize, dpiScale), // don't round down to 0 7822uniformOrAverageContainerSize = Math.Round(sumOfContainerSizes / numContainerSizes); 8485rcChild.Height = Math.Max(arrangeLength, childDesiredSize.Height); 8510previousChildSize.Width = Math.Max(previousChildSize.Width, pixelHeaderSize.Width); 8517rcChild.Width = Math.Max(arrangeLength, childDesiredSize.Width); 8542previousChildSize.Height = Math.Max(previousChildSize.Height, pixelHeaderSize.Height); 8572rcChild.Height = Math.Max(arrangeLength, childDesiredSize.Height); 8578rcChild.Width = Math.Max(arrangeLength, childDesiredSize.Width); 8616rcChild.Height = Math.Max(arrangeLength, childDesiredSize.Height); 8669rcChild.Width = Math.Max(arrangeLength, childDesiredSize.Width); 9544return Math.Max(0, _firstItemInExtendedViewportIndex); 9552return Math.Min(ItemCount, _firstItemInExtendedViewportIndex + _actualItemsInExtendedViewportCount); 9670_scrollData._maxDesiredSize.Height = Math.Max(_scrollData._maxDesiredSize.Height, stackPixelSize.Height); 9697_scrollData._maxDesiredSize.Width = Math.Max(_scrollData._maxDesiredSize.Width, stackPixelSize.Width); 9723Math.Min(stackPixelSize.Width, constraint.Width) : constraint.Width; 9728Math.Min(stackPixelSize.Height, constraint.Height) : constraint.Height; 9738Debug.Assert(DoubleUtil.AreClose(viewportSize.Width - Math.Floor(viewportSize.Width), 0.0), "The viewport size must not contain fractional values when in item scrolling mode."); 9739Debug.Assert(DoubleUtil.AreClose(extentSize.Width - Math.Floor(extentSize.Width), 0.0), "The extent size must not contain fractional values when in item scrolling mode."); 9743Debug.Assert(DoubleUtil.AreClose(viewportSize.Height - Math.Floor(viewportSize.Height), 0.0), "The viewport size must not contain fractional values when in item scrolling mode."); 9744Debug.Assert(DoubleUtil.AreClose(extentSize.Height - Math.Floor(extentSize.Height), 0.0), "The extent size must not contain fractional values when in item scrolling mode."); 9997double proposedViewportSize = Math.Floor(viewport.Width / approxSizeOfLogicalUnit); 10090if (!LayoutDoubleUtil.AreClose(Math.Floor(computedViewportOffset.X)/extentSize.Width, Math.Floor(_scrollData._offset.X)/_scrollData._extent.Width)) 10093viewportOffset.X = Math.Floor((extentSize.Width * Math.Floor(_scrollData._offset.X)) / _scrollData._extent.Width); 10214double proposedViewportSize = Math.Floor(viewport.Height / approxSizeOfLogicalUnit); 10307if (!LayoutDoubleUtil.AreClose(Math.Floor(computedViewportOffset.Y)/extentSize.Height, Math.Floor(_scrollData._offset.Y)/_scrollData._extent.Height)) 10310viewportOffset.Y = Math.Floor((extentSize.Height * Math.Floor(_scrollData._offset.Y)) / _scrollData._extent.Height); 10522_scrollData._maxDesiredSize.Height = Math.Max(_scrollData._maxDesiredSize.Height, stackPixelSize.Height); 10549_scrollData._maxDesiredSize.Width = Math.Max(_scrollData._maxDesiredSize.Width, stackPixelSize.Width); 10575Math.Min(stackPixelSize.Width, constraint.Width) : constraint.Width; 10580Math.Min(stackPixelSize.Height, constraint.Height) : constraint.Height; 10590Debug.Assert(DoubleUtil.AreClose(viewportSize.Width - Math.Floor(viewportSize.Width), 0.0), "The viewport size must not contain fractional values when in item scrolling mode."); 10591Debug.Assert(DoubleUtil.AreClose(extentSize.Width - Math.Floor(extentSize.Width), 0.0), "The extent size must not contain fractional values when in item scrolling mode."); 10595Debug.Assert(DoubleUtil.AreClose(viewportSize.Height - Math.Floor(viewportSize.Height), 0.0), "The viewport size must not contain fractional values when in item scrolling mode."); 10596Debug.Assert(DoubleUtil.AreClose(extentSize.Height - Math.Floor(extentSize.Height), 0.0), "The extent size must not contain fractional values when in item scrolling mode."); 10676lastPageSafeOffset = lastPageSafeOffset.HasValue ? Math.Min(computedViewportOffset.X, (double)lastPageSafeOffset) : computedViewportOffset.X; 10679double proposedViewportSize = Math.Floor(viewport.Width / approxSizeOfLogicalUnit); 10761if (!LayoutDoubleUtil.AreClose(Math.Floor(computedViewportOffset.X)/extentSize.Width, Math.Floor(_scrollData._offset.X)/_scrollData._extent.Width)) 10764viewportOffset.X = Math.Floor((extentSize.Width * Math.Floor(_scrollData._offset.X)) / _scrollData._extent.Width); 10807lastPageSafeOffset = lastPageSafeOffset.HasValue ? Math.Min(computedViewportOffset.Y, (double)lastPageSafeOffset) : computedViewportOffset.Y; 10810double proposedViewportSize = Math.Floor(viewport.Height / approxSizeOfLogicalUnit); 10892if (!LayoutDoubleUtil.AreClose(Math.Floor(computedViewportOffset.Y)/extentSize.Height, Math.Floor(_scrollData._offset.Y)/_scrollData._extent.Height)) 10895viewportOffset.Y = Math.Floor((extentSize.Height * Math.Floor(_scrollData._offset.Y)) / _scrollData._extent.Height); 11193double visibleStart = Math.Max(start, 0); 11194double visibleEnd = Math.Max(Math.Min(end, viewportSize), visibleStart); 11239else if (childIndex > firstChildInView + Math.Max(viewportSize - 1, 0)) 11285maxChildLength = Math.Max(maxChildLength, childSize.Height); 11289maxChildLength = Math.Max(maxChildLength, childSize.Width); 11881else if (DoubleUtil.GreaterThan(Math.Abs(newOffset - oldOffset), _viewport.Width)) 11897else if (DoubleUtil.GreaterThan(Math.Abs(newOffset - oldOffset), _viewport.Height))

253panelSize.U = Math.Max(curLineSize.U, panelSize.U); 259panelSize.U = Math.Max(sz.U, panelSize.U); 267curLineSize.V = Math.Max(sz.V, curLineSize.V); 272panelSize.U = Math.Max(curLineSize.U, panelSize.U); 327curLineSize.V = Math.Max(sz.V, curLineSize.V);

489double maxLineHeight = Math.Min(1000000, PTS.MaxFontSize); 533double maxThickness = Math.Min(1000000, PTS.MaxPageSize);

410deltaToScroll = Math.Abs(targetPoint.Y); 411scroller.ScrollToVerticalOffset(Math.Max(0, scroller.VerticalOffset - deltaToScroll - scrollerHeight / 4)); 417scroller.ScrollToVerticalOffset(Math.Min(scroller.ExtentHeight, scroller.VerticalOffset + deltaToScroll + scrollerHeight / 4)); 427deltaToScroll = Math.Abs(targetPoint.X); 428scroller.ScrollToHorizontalOffset(Math.Max(0, scroller.HorizontalOffset - deltaToScroll - scrollerWidth / 4)); 434scroller.ScrollToHorizontalOffset(Math.Min(scroller.ExtentWidth, scroller.HorizontalOffset + deltaToScroll + scrollerWidth / 4));

1039distance = Math.Abs(distance);

300double maxOffset = Math.Min(1000000, PTS.MaxPageSize);

138line = Math.Max(0, Math.Min(line, _lineResults.Length - 1)); 163double absVerDistance = Math.Max(0, (pt.Y > lineResult.LayoutBox.Y) ? (pt.Y - lineResult.LayoutBox.Bottom) : (lineResult.LayoutBox.Y - pt.Y)); 164double absHorDistance = Math.Max(0, (pt.X > lineResult.LayoutBox.X) ? (pt.X - lineResult.LayoutBox.Right) : (lineResult.LayoutBox.X - pt.X));

558if (Math.Abs(textRunRect.Left - fixedBlockRect.Left) <= textRun.DefaultCharWidth || 559Math.Abs(textRunRect.Right - fixedBlockRect.Right) <= textRun.DefaultCharWidth) 1031if (Math.Abs(t.BoundingRect.Left - row.BoundingRect.Left) < fudge && 1032Math.Abs(t.BoundingRect.Right - row.BoundingRect.Right) < fudge && 1033Math.Abs(t.BoundingRect.Bottom - row.BoundingRect.Top) < fudge)

218double overlap = Math.Abs(thisRectRefX - otherRectRefX);

141double yScale = Math.Sqrt(mat.M12*mat.M12 + mat.M22*mat.M22); 142double xScale = Math.Sqrt(mat.M11 * mat.M11 + mat.M21 * mat.M21);

881double xDistance = Math.Abs(currentPt.X - prevPt.X); 882double maxHeight = Math.Max(box1.Height, box2.Height);

848double horizontalDistance = Math.Max(0, (transformedPt.X > alignmentRect.X) ? (transformedPt.X - alignmentRect.Right) : (alignmentRect.X - transformedPt.X)); 849double verticalDistance = Math.Max(0, (transformedPt.Y > alignmentRect.Y) ? (transformedPt.Y - alignmentRect.Bottom) : (alignmentRect.Y - transformedPt.Y));

133double maxWidth = Math.Min(1000000, PTS.MaxPageSize);

1529double maxSize = Math.Min(1000000, PTS.MaxPageSize); 1544double maxSize = Math.Min(1000000, PTS.MaxPageSize); 1559double maxSize = Math.Min(1000000, PTS.MaxPageSize); 1580double maxRuleWidth = Math.Min(1000000, PTS.MaxPageSize); 1591double maxGap = Math.Min(1000000, PTS.MaxPageSize);

218maxLength = Math.Min(maxLength, remainingLength); 315distance = Math.Abs(distance);

157Math.Max(0, designRect.Right), 158Math.Max(0, designRect.Bottom) 534estimatedNumberOfGlyphs = Math.Max(estimatedNumberOfGlyphs, glyphsProp.Length / 5);

674milPointTopLeft = new Point(Math.Min(rectStart.Left, rectEnd.Left), Math.Min(rectStart.Top, rectEnd.Top)); 675milPointBottomRight = new Point(Math.Max(rectStart.Left, rectEnd.Left), Math.Max(rectStart.Bottom, rectEnd.Bottom)); 1128_caretOffset = Math.Min(_caretOffset, text.Length);

327double maxOffset = Math.Min(1000000, PTS.MaxPageSize);

303double maxIndent = Math.Min(1000000, PTS.MaxPageSize);

308newBuffer = new char[Math.Max(2*_buffer.Length, size)];

1017int timeOutOffset = Math.Min(data.TextMap.ContentEndOffset, sentenceEndOffset); 1201sTextRange = (SpellerInteropBase.ITextRange)segments[Math.Max(i, 0)]; 1204contextOffset = Math.Min(sTextRange.Start, contentOffset); 1209sTextRange = (SpellerInteropBase.ITextRange)segments[Math.Min(i, segments.Count-1)]; 1212contextOffset = Math.Max(sTextRange.Start + sTextRange.Length, contentOffset); 1718runCount = Math.Min(runCount, _text.Length - _textLength); 1719runCount = Math.Min(runCount, position.GetOffsetToPosition(contextEnd));

207get { return Math.Max(CellSpacing, 0); } 387double maxSpacing = Math.Min(1000000, PTS.MaxPageSize);

205double maxPixel = Math.Min(1000000, PTS.MaxPageSize);

228_columnCount = Math.Max(_columnCount, Rows[i].ColumnCount);

240change.RemovedLength += Math.Max(0, length - change.AddedLength); 241change.AddedLength = Math.Max(0, change.AddedLength - length); 403int cancelledCount = Math.Min(overlap, newChange.RemovedLength);

524_mouseSelectionState.Timer.Interval = TimeSpan.FromMilliseconds(Math.Max(SystemParameters.MenuShowDelay, 200)); 1191int extraCharsAllowed = Math.Max(0, this.MaxLength - currentLength);

1606double maxFontSize = Math.Min(1000000, PTS.MaxFontSize);

216int textBlockLength = Math.Max(TextBlockLength, findPattern.Length * 2 * 2); 671runCount = Math.Min(runCount, findText.Length - findTextLength); 675runCount = Math.Min(runCount, navigator.GetOffsetToPosition(endPosition)); 685runCount = Math.Min(runCount, startPosition.GetOffsetToPosition(navigator));

1795finalCount += Math.Min(count - finalCount, textNode.SymbolCount - skipCount);

104maxCount = Math.Min(count, thisPointer.GetOffsetToPosition(limit)); 108maxCount = Math.Min(count, limit.GetOffsetToPosition(thisPointer)); 110maxCount = Math.Min(count, maxCount); 1429runLength = Math.Min(navigator.GetTextRunLength(LogicalDirection.Backward), SelectionWordBreaker.MinContextLength - preceedingCount); 1448runLength = Math.Min(navigator.GetTextRunLength(LogicalDirection.Forward), SelectionWordBreaker.MinContextLength - followingCount);

2348new DoublePropertyRange (Paragraph.TextIndentProperty, -Math.Min(1000000, PTS.MaxPageSize), Math.Min(1000000, PTS.MaxPageSize)) 2370double retValue = Math.Max(_lowerBound, value); 2371retValue = Math.Min(retValue, _upperBound);

335int firstRowIndex = Math.Min(anchorCell.Row.Index, movingCell.Row.Index); 336int lastRowIndex = Math.Max(anchorCell.Row.Index + anchorCell.RowSpan - 1, movingCell.Row.Index + movingCell.RowSpan - 1); 337int firstColumnIndex = Math.Min(anchorCell.ColumnIndex, movingCell.ColumnIndex); 338int lastColumnIndex = Math.Max(anchorCell.ColumnIndex + anchorCell.ColumnSpan - 1, movingCell.ColumnIndex + movingCell.ColumnSpan - 1); 1428int cCols = Math.Abs(columnCount); 1710_dxr = Math.Max(_dxr, 0.0); 1733xPosAdorner = Math.Max(xPosAdorner, _columnRect.Left - this.LeftDragMax); 1734xPosAdorner = Math.Min(xPosAdorner, _columnRect.Right + this.RightDragMax); 1745dx = Math.Max(dx, - this.LeftDragMax); 1746dx = Math.Min(dx, this.RightDragMax);

2251caretRectangle.Y += caretRectangle.Height - Math.Abs(bottom.Y - top.Y); 2252caretRectangle.Height = Math.Abs(bottom.Y - top.Y);

1000milPointTopLeft = new Point(Math.Min(rectPrev.Left, rectCur.Left), Math.Min(rectPrev.Top, rectCur.Top)); 1001milPointBottomRight = new Point(Math.Max(rectPrev.Left, rectCur.Left), Math.Max(rectPrev.Bottom, rectCur.Bottom)); 2479runCount = TextPointerBase.GetTextWithLimit(navigator, LogicalDirection.Forward, text, charsCopied, Math.Min(cchReq, text.Length - charsCopied), limit); 2880double radSin = Math.Asin(tf.M12 / Math.Sqrt((tf.M11 * tf.M11) + (tf.M12 * tf.M12))); 2881double radCos = Math.Acos(tf.M11 / Math.Sqrt((tf.M11 * tf.M11) + (tf.M12 * tf.M12))); 2883double angleCos = Math.Round((radCos * 180) / Math.PI, 0); 3846int extraCharsAllowed = Math.Max(0, this.TextEditor.MaxLength - currentLength);

104firstCount = Math.Min(count, firstBlock.Count - firstBlockLocalOffset); 301count = Math.Min(rightBlock.FreeCapacity, length - textOffset); 343count = Math.Min(neighborBlock.FreeCapacity, textEndOffset - textOffset); 357count = Math.Min(rightBlock.FreeCapacity, textEndOffset - textOffset);

95newText = new char[Math.Min(this.Count + count, MaxBlockSize)]; 110count = Math.Min(count, _gapSize); 249copyCount = Math.Min(count, _gapOffset - logicalOffset); 264copyCount = Math.Min(count, _text.Length - logicalOffset);

198(long)Math.Floor(1.0d * _instanceInfo.CumulativeCallTime100Ns[_action] / _instanceInfo.NumCallsMeasured[_action]); 219CallTimeForCOMCallMs = (long)Math.Floor(ticks * 1.0d / 10000), 220RunningAverageCallTimeForCOMCallsMs = (long)Math.Floor(runningAverage * 1.0d / 10000)

175int altFormsCount = Math.Min(missingFragmentText.Length, AlternateFormsMaximumCount);

1732tableWidth = Math.Max(tableWidth, lastCellX); 2893formatState.FontSize = (long)Math.Round(fs);

101double maxPixel = Math.Min(1000000, PTS.MaxPageSize);

4059maxHeight = Math.Max(Math.Min(height, maxHeight), minHeight); 4062minHeight = Math.Max(Math.Min(maxHeight, height), minHeight); 4069maxWidth = Math.Max(Math.Min(width, maxWidth), minWidth); 4072minWidth = Math.Max(Math.Min(maxWidth, width), minWidth); 4174Double yCoverD = (yConstrInfinite ? Double.PositiveInfinity : Math.Abs(yConstr/d)); 4175Double xCoverA = (xConstrInfinite ? Double.PositiveInfinity : Math.Abs(xConstr/a)); 4195h = Math.Min(0.5*Math.Abs(xConstr/c), yCoverD); 4206w = Math.Min( 0.5*Math.Abs(yConstr/b), xCoverA); 4214Double yCoverB = Math.Abs(yConstr/b); 4215Double xCoverC = Math.Abs(xConstr/c); 4235h = Math.Min(0.5*Math.Abs(yConstr/d), xCoverC); 4246w = Math.Min( 0.5*Math.Abs(xConstr/a), yCoverB); 4252Double xCoverA = Math.Abs(xConstr / a); // w-intercept of x-constraint line. 4253Double xCoverC = Math.Abs(xConstr / c); // h-intercept of x-constraint line. 4255Double yCoverB = Math.Abs(yConstr / b); // w-intercept of y-constraint line. 4256Double yCoverD = Math.Abs(yConstr / d); // h-intercept of y-constraint line. 4263w = Math.Min(yCoverB, xCoverA) * 0.5; 4264h = Math.Min(xCoverC, yCoverD) * 0.5; 4281Double expandFactor = Math.Min(xConstr / childBoundsTr.Width, 4340Math.Max(availableSize.Width - marginWidth, 0), 4341Math.Max(availableSize.Height - marginHeight, 0)); 4389frameworkAvailableSize.Width = Math.Max(mm.minWidth, Math.Min(frameworkAvailableSize.Width, mm.maxWidth)); 4390frameworkAvailableSize.Height = Math.Max(mm.minHeight, Math.Min(frameworkAvailableSize.Height, mm.maxHeight)); 4403Math.Max(desiredSize.Width, mm.minWidth), 4404Math.Max(desiredSize.Height, mm.minHeight)); 4470ltd.TransformedUnroundedDS = new Size(Math.Max(0, clippedDesiredWidth), Math.Max(0, clippedDesiredHeight)); 4517return new Size(Math.Max(0, clippedDesiredWidth), Math.Max(0, clippedDesiredHeight)); 4579arrangeSize.Width = Math.Max(0, arrangeSize.Width - marginWidth); 4580arrangeSize.Height = Math.Max(0, arrangeSize.Height - marginHeight); 4589transformedUnroundedDS.Width = Math.Max(0, transformedUnroundedDS.Width - marginWidth); 4590transformedUnroundedDS.Height = Math.Max(0, transformedUnroundedDS.Height- marginHeight); 4599unclippedDesiredSize = new Size(Math.Max(0, this.DesiredSize.Width - marginWidth), 4600Math.Max(0, this.DesiredSize.Height - marginHeight)); 4605unclippedDesiredSize.Width = Math.Max(transformedUnroundedDS.Width, unclippedDesiredSize.Width); 4606unclippedDesiredSize.Height = Math.Max(transformedUnroundedDS.Height, unclippedDesiredSize.Height); 4693double effectiveMaxWidth = Math.Max(unclippedDesiredSize.Width, mm.maxWidth); 4700double effectiveMaxHeight = Math.Max(unclippedDesiredSize.Height, mm.maxHeight); 4731Size clippedInkSize = new Size(Math.Min(innerInkSize.Width, mm.maxWidth), 4732Math.Min(innerInkSize.Height, mm.maxHeight)); 4764Size clientSize = new Size(Math.Max(0, finalRect.Width - marginWidth), 4765Math.Max(0, finalRect.Height - marginHeight)); 4914inkSize.Width = Math.Min(inkSize.Width, mm.maxWidth); 4915inkSize.Height = Math.Min(inkSize.Height, mm.maxHeight); 4932Size clippingSize = new Size(Math.Max(0, layoutSlotSize.Width - marginWidth), 4933Math.Max(0, layoutSlotSize.Height - marginHeight)); 5245inkSize.Width = Math.Min(inkSize.Width, mm.maxWidth); 5246inkSize.Height = Math.Min(inkSize.Height, mm.maxHeight);

2518rect.Height = Math.Min(Math.Max(before, 0.0d), rect.Height); 2522double height = Math.Min(Math.Max(after, 0.0d), rect.Height); 2538return Math.Sqrt(deltaX * deltaX + deltaY * deltaY); 2669startRange = Math.Min(startRange, _horizontalBaseline); 2670endRange = Math.Max(endRange, _horizontalBaseline); 2690startRange = Math.Min(startRange, _verticalBaseline); 2691endRange = Math.Max(endRange, _verticalBaseline);

707desiredSize.Width = Math.Min(_desiredSize.Width, constraint.Width); 708desiredSize.Height = Math.Min(_desiredSize.Height, constraint.Height);

150long end = Math.Min(_position + 1, _length); 175long end = Math.Min(_position + count, _length);

1752defKeyList = new ArrayList(Math.Max (5, (int)(bamlRecord.ContentSize/400)));

98width = Math.Min(width, height); 102width = Math.Max(width, height); 125Math.Max(0, finalSize.Width - penThickness), // Width 126Math.Max(0, finalSize.Height - penThickness)); // Height

150width = Math.Min(width, height); 154width = Math.Max(width, height); 178Math.Max(0, finalSize.Width - penThickness), // Width 179Math.Max(0, finalSize.Height - penThickness)); // Height

470return Math.Abs(StrokeThickness); 486thickness = Math.Abs(strokeThickness); 587xScale = Math.Max(availableSize.Width - strokeThickness, 0); 588yScale = Math.Max(availableSize.Height - strokeThickness, 0); 715return new Size(Math.Max(bounds.Right, 0), 716Math.Max(bounds.Bottom, 0));

108progressValue = Math.Max(progressValue, 0); 109progressValue = Math.Min(1, progressValue);

1065double shortestDimension = Math.Min(windowSize.Width, windowSize.Height); 1068topLeftRadius = Math.Min(topLeftRadius, shortestDimension / 2); 1084topRightRadius = Math.Min(topRightRadius, shortestDimension / 2); 1092bottomLeftRadius = Math.Min(bottomLeftRadius, shortestDimension / 2); 1100bottomRightRadius = Math.Min(bottomRightRadius, shortestDimension / 2); 1127(int)Math.Floor(region.Left), 1128(int)Math.Floor(region.Top), 1129(int)Math.Ceiling(region.Right), 1130(int)Math.Ceiling(region.Bottom)); 1135(int)Math.Floor(region.Left), 1136(int)Math.Floor(region.Top), 1137(int)Math.Ceiling(region.Right) + 1, 1138(int)Math.Ceiling(region.Bottom) + 1, 1139(int)Math.Ceiling(radius), 1140(int)Math.Ceiling(radius)); 1228deviceGlassThickness.Top = Math.Max(0, deviceGlassThickness.Top); 1233deviceGlassThickness.Left = Math.Max(0, deviceGlassThickness.Left); 1238deviceGlassThickness.Bottom = Math.Max(0, deviceGlassThickness.Bottom); 1243deviceGlassThickness.Right = Math.Max(0, deviceGlassThickness.Right); 1250cxLeftWidth = (int)Math.Ceiling(deviceGlassThickness.Left), 1251cxRightWidth = (int)Math.Ceiling(deviceGlassThickness.Right), 1252cyTopHeight = (int)Math.Ceiling(deviceGlassThickness.Top), 1253cyBottomHeight = (int)Math.Ceiling(deviceGlassThickness.Bottom),

2049Left = Math.Min(rect1.Left, rect2.Left), 2050Top = Math.Min(rect1.Top, rect2.Top), 2051Right = Math.Max(rect1.Right, rect2.Right), 2052Bottom = Math.Max(rect1.Bottom, rect2.Bottom),

1017return (double)(Math.Abs(height) * 96 / dpi);

1769frameworkAvailableSize.Width = Math.Max(mm.minWidth, Math.Min(frameworkAvailableSize.Width, mm.maxWidth)); 1770frameworkAvailableSize.Height = Math.Max(mm.minHeight, Math.Min(frameworkAvailableSize.Height, mm.maxHeight)); 1777Math.Max(desiredSize.Width, mm.minWidth), 1778Math.Max(desiredSize.Height, mm.minHeight)); 1799arrangeBounds.Width = Math.Max(mm.minWidth, Math.Min(arrangeBounds.Width, mm.maxWidth)); 1800arrangeBounds.Height = Math.Max(mm.minHeight, Math.Min(arrangeBounds.Height, mm.maxHeight)); 1834childArrangeBounds.Width = Math.Max(0.0, arrangeBounds.Width - frameSize.Width); 1835childArrangeBounds.Height = Math.Max(0.0, arrangeBounds.Height - frameSize.Height); 3311childConstraint.Width = ((constraint.Width == Double.PositiveInfinity) ? Double.PositiveInfinity : Math.Max(0.0, (constraint.Width - frameSize.Width))); 3312childConstraint.Height = ((constraint.Height == Double.PositiveInfinity) ? Double.PositiveInfinity : Math.Max(0.0, (constraint.Height - frameSize.Height))); 3356maxWidthDeviceUnits = Math.Max(_trackMaxWidthDeviceUnits, _windowMaxWidthDeviceUnits); 3357maxHeightDeviceUnits = Math.Max(_trackMaxHeightDeviceUnits, _windowMaxHeightDeviceUnits); 3366mm.minWidth = Math.Max(this.MinWidth, minSizeLogicalUnits.X); 3371mm.maxWidth = Math.Min(MinWidth, maxSizeLogicalUnits.X); 3377mm.maxWidth = Math.Min(MaxWidth, maxSizeLogicalUnits.X); 3388mm.minHeight = Math.Max(this.MinHeight, minSizeLogicalUnits.Y); 3393mm.maxHeight = Math.Min(this.MinHeight, maxSizeLogicalUnits.Y); 3399mm.maxHeight = Math.Min(MaxHeight, maxSizeLogicalUnits.Y); 3769leftDeviceUnits = Math.Min(leftDeviceUnits, workAreaRectDeviceUnits.right - currentSizeDeviceUnits.Width); 3770leftDeviceUnits = Math.Max(leftDeviceUnits, workAreaRectDeviceUnits.left); 3771topDeviceUnits = Math.Min(topDeviceUnits, workAreaRectDeviceUnits.bottom - currentSizeDeviceUnits.Height); 3772topDeviceUnits = Math.Max(topDeviceUnits, workAreaRectDeviceUnits.top); 4632_windowMaxWidthDeviceUnits = Math.Max(_windowMaxWidthDeviceUnits, windowSize.X); 4633_windowMaxHeightDeviceUnits = Math.Max(_windowMaxHeightDeviceUnits, windowSize.Y); 7523return new Size(Math.Max(0.0, pt.X), Math.Max(0.0, pt.Y));

434desired = new Size(Math.Min(4.0, availableSize.Width), Math.Min(4.0, availableSize.Height)); 452childArrangeRect.Width = Math.Max(0d, finalSize.Width - 4.0); 453childArrangeRect.Height = Math.Max(0d, finalSize.Height - 4.0);

255desired = new Size(Math.Min(borderX, availableSize.Width), Math.Min(borderY, availableSize.Height));

471bounds.Width = Math.Max(0.0, bounds.Width - 1.0); 542double height = Math.Min(7.0, bounds.Height); 565double width = Math.Min(7.0, bounds.Width); 729double widthScale = Math.Min(glyphWidth, bounds.Width) / glyphWidth; 730double heightScale = Math.Min(glyphHeight, bounds.Height) / glyphHeight;

193childWidth = Math.Max(0.0, childWidth - padding.Left - padding.Right); 198childHeight = Math.Max(0.0, childHeight - padding.Top - padding.Bottom); 233double childWidth = Math.Max(0.0, arrangeSize.Width - padding.Left - padding.Right); 234double childHeight = Math.Max(0.0, arrangeSize.Height - padding.Top - padding.Bottom); 300return Math.Max(0.0, d);

116double maxRadius = Math.Min(centerWidth * 0.5, centerHeight * 0.5); 117cornerRadius.TopLeft = Math.Min(cornerRadius.TopLeft, maxRadius); 118cornerRadius.TopRight = Math.Min(cornerRadius.TopRight, maxRadius); 119cornerRadius.BottomLeft = Math.Min(cornerRadius.BottomLeft, maxRadius); 120cornerRadius.BottomRight = Math.Min(cornerRadius.BottomRight, maxRadius);

434desired = new Size(Math.Min(4.0, availableSize.Width), Math.Min(4.0, availableSize.Height)); 452childArrangeRect.Width = Math.Max(0d, finalSize.Width - 4.0); 453childArrangeRect.Height = Math.Max(0d, finalSize.Height - 4.0);

255desired = new Size(Math.Min(borderX, availableSize.Width), Math.Min(borderY, availableSize.Height));

471bounds.Width = Math.Max(0.0, bounds.Width - 1.0); 542double height = Math.Min(7.0, bounds.Height); 565double width = Math.Min(7.0, bounds.Width); 729double widthScale = Math.Min(glyphWidth, bounds.Width) / glyphWidth; 730double heightScale = Math.Min(glyphHeight, bounds.Height) / glyphHeight;

193childWidth = Math.Max(0.0, childWidth - padding.Left - padding.Right); 198childHeight = Math.Max(0.0, childHeight - padding.Top - padding.Bottom); 233double childWidth = Math.Max(0.0, arrangeSize.Width - padding.Left - padding.Right); 234double childHeight = Math.Max(0.0, arrangeSize.Height - padding.Top - padding.Bottom); 300return Math.Max(0.0, d);

116double maxRadius = Math.Min(centerWidth * 0.5, centerHeight * 0.5); 117cornerRadius.TopLeft = Math.Min(cornerRadius.TopLeft, maxRadius); 118cornerRadius.TopRight = Math.Min(cornerRadius.TopRight, maxRadius); 119cornerRadius.BottomLeft = Math.Min(cornerRadius.BottomLeft, maxRadius); 120cornerRadius.BottomRight = Math.Min(cornerRadius.BottomRight, maxRadius);

247double height = Math.Min(7.0, bounds.Height); 262double width = Math.Min(7.0, bounds.Width);

193childWidth = Math.Max(0.0, childWidth - padding.Left - padding.Right); 198childHeight = Math.Max(0.0, childHeight - padding.Top - padding.Bottom); 233double childWidth = Math.Max(0.0, arrangeSize.Width - padding.Left - padding.Right); 234double childHeight = Math.Max(0.0, arrangeSize.Height - padding.Top - padding.Bottom); 300return Math.Max(0.0, d);

86int blocks = (int)Math.Ceiling(width / blockTotal); 161if (!isIndeterminate && remainder > 0.0 && Math.Abs(width - trackWidth) < 1.0e-5)

116double maxRadius = Math.Min(centerWidth * 0.5, centerHeight * 0.5); 117cornerRadius.TopLeft = Math.Min(cornerRadius.TopLeft, maxRadius); 118cornerRadius.TopRight = Math.Min(cornerRadius.TopRight, maxRadius); 119cornerRadius.BottomLeft = Math.Min(cornerRadius.BottomLeft, maxRadius); 120cornerRadius.BottomRight = Math.Min(cornerRadius.BottomRight, maxRadius);

239float min = Math.Min(rgbColor.Red, Math.Min(rgbColor.Green, rgbColor.Blue)); 240float max = Math.Max(rgbColor.Red, Math.Max(rgbColor.Green, rgbColor.Blue)); 272saturation = Math.Max(0.0f, Math.Min(saturation, 1.0f)); 327float hue = (float)((hlsColor.Hue - Math.Floor(hlsColor.Hue)) * 6); 603Math.Max(0.0, rt.Width - thick.Left - thick.Right), 604Math.Max(0.0, rt.Height - thick.Top - thick.Bottom)); 692desired = new Size(Math.Min(borderSize.Width, availableSize.Width), Math.Min(borderSize.Height, availableSize.Height));

193childWidth = Math.Max(0.0, childWidth - padding.Left - padding.Right); 198childHeight = Math.Max(0.0, childHeight - padding.Top - padding.Bottom); 233double childWidth = Math.Max(0.0, arrangeSize.Width - padding.Left - padding.Right); 234double childHeight = Math.Max(0.0, arrangeSize.Height - padding.Top - padding.Bottom); 300return Math.Max(0.0, d);

86int blocks = (int)Math.Ceiling(width / blockTotal); 161if (!isIndeterminate && remainder > 0.0 && Math.Abs(width - trackWidth) < 1.0e-5)

116double maxRadius = Math.Min(centerWidth * 0.5, centerHeight * 0.5); 117cornerRadius.TopLeft = Math.Min(cornerRadius.TopLeft, maxRadius); 118cornerRadius.TopRight = Math.Min(cornerRadius.TopRight, maxRadius); 119cornerRadius.BottomLeft = Math.Min(cornerRadius.BottomLeft, maxRadius); 120cornerRadius.BottomRight = Math.Min(cornerRadius.BottomRight, maxRadius);

349desired = new Size(Math.Min(sideThickness2, availableSize.Width), Math.Min(sideThickness2, availableSize.Height)); 367childArrangeRect.Width = Math.Max(0d, finalSize.Width - sideThickness2); 368childArrangeRect.Height = Math.Max(0d, finalSize.Height - sideThickness2);

310bounds.Width = Math.Max(0.0, bounds.Width - 1.0); 384double height = Math.Min(6.0, bounds.Height); 406double width = Math.Min(6.0, bounds.Width); 588double widthScale = Math.Min(glyphWidth, bounds.Width) / glyphWidth; 589double heightScale = Math.Min(glyphHeight, bounds.Height) / glyphHeight;

194desired = new Size(Math.Min(11.0 + borderX, availableSize.Width), Math.Min(11.0 + borderY, availableSize.Height)); 217Math.Max(0, bounds.Width - thickness.Left - thickness.Right), 218Math.Max(0, bounds.Height - thickness.Top - thickness.Bottom)); 459Math.Max(0.0, rt.Width - thick.Left - thick.Right), 460Math.Max(0.0, rt.Height - thick.Top - thick.Bottom));

193childWidth = Math.Max(0.0, childWidth - padding.Left - padding.Right); 198childHeight = Math.Max(0.0, childHeight - padding.Top - padding.Bottom); 233double childWidth = Math.Max(0.0, arrangeSize.Width - padding.Left - padding.Right); 234double childHeight = Math.Max(0.0, arrangeSize.Height - padding.Top - padding.Bottom); 300return Math.Max(0.0, d);

86int blocks = (int)Math.Ceiling(width / blockTotal); 161if (!isIndeterminate && remainder > 0.0 && Math.Abs(width - trackWidth) < 1.0e-5)

116double maxRadius = Math.Min(centerWidth * 0.5, centerHeight * 0.5); 117cornerRadius.TopLeft = Math.Min(cornerRadius.TopLeft, maxRadius); 118cornerRadius.TopRight = Math.Min(cornerRadius.TopRight, maxRadius); 119cornerRadius.BottomLeft = Math.Min(cornerRadius.BottomLeft, maxRadius); 120cornerRadius.BottomRight = Math.Min(cornerRadius.BottomRight, maxRadius);

307desired = new Size(Math.Min(sideThickness2, availableSize.Width), Math.Min(sideThickness2, availableSize.Height)); 325childArrangeRect.Width = Math.Max(0d, finalSize.Width - sideThickness2); 326childArrangeRect.Height = Math.Max(0d, finalSize.Height - sideThickness2);

344double height = Math.Min(6.0, bounds.Height); 366double width = Math.Min(6.0, bounds.Width); 548double widthScale = Math.Min(glyphWidth, bounds.Width) / glyphWidth; 549double heightScale = Math.Min(glyphHeight, bounds.Height) / glyphHeight;

194desired = new Size(Math.Min(11.0 + borderX, availableSize.Width), Math.Min(11.0 + borderY, availableSize.Height)); 217Math.Max(0, bounds.Width - thickness.Left - thickness.Right), 218Math.Max(0, bounds.Height - thickness.Top - thickness.Bottom)); 459Math.Max(0.0, rt.Width - thick.Left - thick.Right), 460Math.Max(0.0, rt.Height - thick.Top - thick.Bottom));

193childWidth = Math.Max(0.0, childWidth - padding.Left - padding.Right); 198childHeight = Math.Max(0.0, childHeight - padding.Top - padding.Bottom); 233double childWidth = Math.Max(0.0, arrangeSize.Width - padding.Left - padding.Right); 234double childHeight = Math.Max(0.0, arrangeSize.Height - padding.Top - padding.Bottom); 300return Math.Max(0.0, d);

86int blocks = (int)Math.Ceiling(width / blockTotal); 161if (!isIndeterminate && remainder > 0.0 && Math.Abs(width - trackWidth) < 1.0e-5)

116double maxRadius = Math.Min(centerWidth * 0.5, centerHeight * 0.5); 117cornerRadius.TopLeft = Math.Min(cornerRadius.TopLeft, maxRadius); 118cornerRadius.TopRight = Math.Min(cornerRadius.TopRight, maxRadius); 119cornerRadius.BottomLeft = Math.Min(cornerRadius.BottomLeft, maxRadius); 120cornerRadius.BottomRight = Math.Min(cornerRadius.BottomRight, maxRadius);

169int maxWidth = Math.Max(_addButton.Width, _removeButton.Width);

575int h = Math.Max(Math.Max(Math.Max(Math.Max(IconHeight,heightSummary), heightIntent), heightLocale), heightSignBy);

129double percentDone = Math.Floor((double)bytesDownloaded / (double)bytesTotal * 100.0);

516rb.RadiusX = Math.Abs(rb.RadiusX * bounds.Width); 517rb.RadiusY = Math.Abs(rb.RadiusY * bounds.Height); 1916double length = Math.Sqrt(dx * dx + dy * dy); 1930stopDistance = Math.Max(b.RadiusX, b.RadiusY) * (second.Offset - first.Offset); 1948int stopCount = (int)Math.Ceiling(-6.297427 + 4.591693 * Math.Log(stopDistance)); 2287double height = Math.Abs(start.Y - end.Y) * multiplier; 2296double width = Math.Abs(start.X - end.X) * multiplier; 2577if (Utility.AreClose(new Vector(Math.Abs(rbA.RadiusX), Math.Abs(rbA.RadiusY)) * rbA.Transform.Value, 2578new Vector(Math.Abs(rbB.RadiusX), Math.Abs(rbB.RadiusY)) * rbB.Transform.Value)) 3746min = Math.Min(min, offset); 3747max = Math.Max(max, offset); 3873return Math.Sqrt(sum); 3902return (int)Math.Ceiling(Math.Max(5, step)); // At least five. Radials look bad with less steps. 3951if (Math.Abs(di) < Double.Epsilon) 4045double right = Math.Ceiling(_bounds.Right / _bandDelta); 4046double left = Math.Floor(_bounds.Left / _bandDelta); 4145double rotateAngle = Math.Atan2(-gradientVector.Y, gradientVector.X) * 180.0 / Math.PI; 4190_rx = Math.Abs(b.RadiusX); 4191_ry = Math.Abs(b.RadiusY); 4272double right = Math.Ceiling(maxt * _bandSteps); 4273double left = Math.Floor(mint * _bandSteps); 4388double root = Math.Sqrt(B4AC); 4397maxt = Math.Max(maxt, one); 4398mint = Math.Min(mint, one); 4405maxt = Math.Max(maxt, two); 4406mint = Math.Min(mint, two); 4431double len = Math.Sqrt(dx * dx + dy * dy);

606int width = (int) Math.Round(bounds.Width * Configuration.RasterizationDPI / 96); 607int height = (int) Math.Round(bounds.Height * Configuration.RasterizationDPI / 96); 664return 512 + Configuration.RasterizationCost(Math.Max(bounds.Width, bounds.Height));

1231uint dcDpi = Math.Max(PrintQueue.GetDpiX(dc), PrintQueue.GetDpiY(dc)); 1232Configuration.RasterizationDPI = (int)(Math.Max(dcDpi, 300));

488int x0 = (int)Math.Max(Math.Floor(bounds.Left), 0); 489int y0 = (int)Math.Max(Math.Floor(bounds.Top), 0); 490int x1 = (int)Math.Ceiling(bounds.Right); 491int y1 = (int)Math.Ceiling(bounds.Bottom);

51int width = (int)Math.Round(m_bounds.Width * Configuration.RasterizationDPI / 96); 52int height = (int)Math.Round(m_bounds.Height * Configuration.RasterizationDPI / 96);

767columnCount = (int)Math.Ceiling((bounds.Right - startTile.Left) / startTile.Width); 776rowCount = (int)Math.Ceiling((bounds.Bottom - startTile.Top) / startTile.Height);

115return Math.Abs(value - 1.0) < Epsilon; 124return Math.Abs(value) < Epsilon; 161double s = Math.Round(scale); 186scale = Math.Sqrt(A); 197x = Math.Abs(x); 198y = Math.Abs(y); 219return y * Math.Sqrt(r * r + 1.0); 235return Math.Max(GetScaleX(trans), GetScaleY(trans)); 1695scale = Math.Min(viewport.Width / viewbox.Width, viewport.Height / viewbox.Height); 1704scale = Math.Max(viewport.Width / viewbox.Width, viewport.Height / viewbox.Height);

42resString.Length = Math.Max(0, Math.Min(charCount, resString.Length));

632int charsToWrite = Math.Min(value.Length, maxCharsToWrite - 1);

160defaultCopies = Math.Max(minCopies, Math.Min(defaultDevMode.Copies, maxCopies));

1183return (short)Math.Max(min, Math.Min(value, max));

684int bytesToWrite = Math.Min(data.Length, (int)(byteCount - totalBytesWritten)); 738int bytesToRead = Math.Min(data.Length, (int)(byteCount - totalBytesRead)); 826return (int)Math.Max(0, Math.Min(value, int.MaxValue)); 831return (int)Math.Min(value, int.MaxValue);

473const double PI_OVER_180 = Math.PI / 180; // PI/180 582rAngle = Math.Atan2(rSinArcAngle, rCosArcAngle); 588rAngle += Math.PI * 2; 595rAngle -= Math.PI * 2; 600rCosArcAngle = Math.Cos(rAngle); 601rSinArcAngle = Math.Sin(rAngle); 680rSin = Math.Sqrt(rSin); // = R*cos(a) 681rCos = Math.Sqrt(rCos); // = R*sin(a) 763double rCos = Math.Cos(rRotation); 764double rSin = Math.Sin(rRotation); 785r = Math.Sqrt(rHalfChord2); 799r = Math.Sqrt((1 - rHalfChord2) / rHalfChord2);