Math

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\GlobalFlowStateAnalysis\GlobalFlowStateAnalysis.GlobalFlowStateAnalysisValueSetDomain.cs (1)

110height: Math.Max(value1.Height, value2.Height) + 1);

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\GlobalFlowStateAnalysis\GlobalFlowStateAnalysisValueSet.cs (1)

159height = Math.Max(height, negatedParent.Height + 1);

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PropertySetAnalysis\PropertySetAnalysis.PropertySetAbstractValueDomain.cs (2)

35int maxKnownCount = Math.Max(oldValue.KnownValuesCount, newValue.KnownValuesCount); 61int maxKnownCount = Math.Max(value1.KnownValuesCount, value2.KnownValuesCount);

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\ValueContentAnalysis\ValueContentAbstractValue.cs (2)

501result = (ulong)Math.Pow(value1, value2); 585result = Math.Pow(value1, value2);

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\DataFlowAnalysis.cs (2)

818var maxSuccessorOrdinal = Math.Max(branch.Destination.GetMaxSuccessorOrdinal(), branch.Source.Ordinal); 822maxSuccessorOrdinal = Math.Max(maxSuccessorOrdinal, branch.FinallyRegions[^1].LastBlockOrdinal);

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\InterproceduralAnalysisConfiguration.cs (3)

109maxKind = (InterproceduralAnalysisKind)Math.Max((int)maxKind, (int)interproceduralAnalysisConfig.InterproceduralAnalysisKind); 110maxMethodCallChain = Math.Max(maxMethodCallChain, interproceduralAnalysisConfig.MaxInterproceduralMethodCallChain); 111maxLambdaorLocalFunctionCallChain = Math.Max(maxLambdaorLocalFunctionCallChain, interproceduralAnalysisConfig.MaxInterproceduralLambdaOrLocalFunctionCallChain);

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.AssemblyMetricData.cs (1)

59depthOfInheritance = Math.Max(child.DepthOfInheritance.GetValueOrDefault(), depthOfInheritance);

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.FieldMetricData.cs (4)

47double computationalComplexityVolume = Math.Max(0.0, Math.Log(computationalComplexityMetrics.Volume)); //avoid Log(0) = -Infinity 48double logEffectiveLinesOfCode = Math.Max(0.0, Math.Log(computationalComplexityMetrics.EffectiveLinesOfCode)); //avoid Log(0) = -Infinity

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.MethodMetricData.cs (4)

58double computationalComplexityVolume = Math.Max(0.0, Math.Log(computationalComplexityMetrics.Volume)); //avoid Log(0) = -Infinity 59double logEffectiveLinesOfCode = Math.Max(0.0, Math.Log(computationalComplexityMetrics.EffectiveLinesOfCode)); //avoid Log(0) = -Infinity

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.NamedTypeMetricData.cs (4)

175double logAvgComputationalComplexityVolume = Math.Max(0.0, Math.Log(avgComputationalComplexityVolume)); //avoid Log(0) = -Infinity 176double logAvgLinesOfCode = Math.Max(0.0, Math.Log(avgEffectiveLinesOfCode)); //avoid Log(0) = -Infinity

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.NamespaceMetricData.cs (1)

57depthOfInheritance = Math.Max(child.DepthOfInheritance.GetValueOrDefault(), depthOfInheritance);

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\ComputationalComplexityMetrics.cs (2)

437=> Length * Math.Max(0.0, Math.Log(Vocabulary, 2));

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (3)

33private static int RoundMetricValue(double value) => (int)Math.Round(value, 0); 37maintIndex = Math.Max(0.0, maintIndex); 93var additionalNewLines = Math.Max(0, GetNewlineCount(declSyntax.GetLeadingTrivia(), leading: true) + GetNewlineCount(declSyntax.GetTrailingTrivia(), leading: false) - 1);

src\RoslynAnalyzers\Utilities\Compiler\SmallDictionary.cs (3)

178return 1 + Math.Max(a, b); 303Math.Abs(a - b) >= 2) 308return 1 + Math.Max(a, b);

src\Analyzers\Core\Analyzers\FileHeaders\AbstractFileHeaderHelper.cs (1)

63fileHeaderStart = Math.Min(trivia.FullSpan.Start, fileHeaderStart);

src\Analyzers\Core\Analyzers\RemoveUnnecessaryParentheses\AbstractRemoveUnnecessaryParenthesesDiagnosticAnalyzer.cs (1)

134var textSpanEndPosition = Math.Min(parenthesizedExpressionLocation.SourceSpan.End, expressionFirstLine.Span.End);

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (2)

566var maxSearchIndex = Math.Min(directoryPathParts.Length, fullPathParts.Length); 648return PathsEqual(path1, path2, Math.Max(path1.Length, path2.Length));

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (1)

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

src\Compilers\Core\Portable\Syntax\SyntaxTreeExtensions.cs (1)

92var n = Math.Min(n1, n2);

src\Compilers\Core\Portable\Text\TextChangeRangeExtensions.cs (1)

224var oldChangeLeadingDeletion = Math.Min(oldChange.Span.Length, oldChangeLeadingInsertion);

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (3)

960TSource[] chunk = new ReadOnlySpan<TSource>(source, index, Math.Min(size, source.Length - index)).ToArray(); 976int arraySize = Math.Min(size, 4); 993arraySize = (int)Math.Min((uint)size, 2 * (uint)array.Length);

src\Dependencies\Collections\Internal\HashHelpers.cs (1)

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

src\Dependencies\Collections\Segmented\SegmentedArray.cs (10)

494var currentSegmentLength = Math.Min(remainingInSegment, _length); 503var currentSegmentLength = Math.Min(SegmentedArrayHelper.GetSegmentSize<T>(), _length - _completed); 598var currentSegmentLength = Math.Min(Math.Min(remainingInFirstSegment, remainingInSecondSegment), _length - _completed); 646var currentSegmentLength = Math.Min(Math.Min(remainingInFirstSegment, remainingInSecondSegment), _length - _completed); 736_current = segment.AsMemory().Slice(offset, Math.Min(remainingInSegment, _length)); 743_current = segment.AsMemory().Slice(0, Math.Min(SegmentedArrayHelper.GetSegmentSize<T>(), _length - _completed)); 785_current = segment.AsMemory().Slice(offset, Math.Min(remainingInSegment, _length)); 792_current = segment.AsMemory().Slice(0, Math.Min(SegmentedArrayHelper.GetSegmentSize<T>(), _length - _completed));

src\Dependencies\Collections\Segmented\SegmentedList`1.cs (1)

544var newSegmentCount = oldSegmentCount + Math.Max(1, oldSegmentCount >> segmentGrowthShiftValue);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\ImmutableIntervalTree`1.cs (1)

198var elementsInLastRowCappedAtMidwayPoint = Math.Min(elementsInLastIncompleteRow, elementsInLastRowIfTreeWerePerfect / 2);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\IntervalTreeAlgorithms`2.cs (2)

146var overlapStart = Math.Max(thisStart, otherStart); 147var overlapEnd = Math.Min(thisEnd, otherEnd);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\MutableIntervalTree`1.Node.cs (1)

35this.Height = 1 + Math.Max(Height(left), Height(right));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (5)

296spans.Add(TextSpan.FromBounds(Math.Max(lastEnd, span1.Start), span1.End)); 307spans.Add(TextSpan.FromBounds(Math.Max(lastEnd, span1.Start), span2.Start)); 334spans.Add(TextSpan.FromBounds(Math.Max(lastEnd, span1.Start), span1.End)); 581end = Math.Max(end, span.End); 617oldEnd = Math.Max(oldEnd, newEnd);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\Common\EmbeddedSyntaxNode.cs (2)

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\Common\EmbeddedSyntaxToken.cs (4)

85Math.Min(LeadingTrivia.Length == 0 ? int.MaxValue : LeadingTrivia[0].GetSpan().Start, 86Math.Min(VirtualChars.Length == 0 ? int.MaxValue : VirtualChars[0].Span.Start, 90Math.Max(LeadingTrivia.Length == 0 ? int.MinValue : LeadingTrivia[^1].GetSpan().End, 91Math.Max(VirtualChars.Length == 0 ? int.MinValue : VirtualChars[^1].Span.End,

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\INamespaceOrTypeSymbolExtensions.cs (1)

43for (var i = 0; i < Math.Min(names1.Count, names2.Count); i++)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\ISymbolExtensions.cs (3)

127if (bestMethod is null || Math.Abs(method.Parameters.Length - parameterCount) < Math.Abs(bestMethod.Parameters.Length - parameterCount)) 497var count = extensionUsedAsInstance ? Math.Max(0, method.Parameters.Length - 1) : method.Parameters.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (2)

305Math.Min(fullSpan.Start, node.SpanStart), 306Math.Max(fullSpan.End, node.Span.End));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\TextSpanExtensions.cs (2)

79var startSegmentEnd = Math.Min(span.End, except.Start); 83var endSegmentStart = Math.Max(span.Start, except.End);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\BottomUpBaseIndentationFinder.cs (2)

173return Math.Max(0, baseIndentation + (indentationLevel + delta) * _indentationSize); 178return Math.Max(0, indentationLevel + extraSpaces);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\AbstractTriviaDataFactory.FormattedWhitespace.cs (2)

21this.LineBreaks = Math.Max(0, lineBreaks); 22this.Spaces = Math.Max(0, indentation);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingExtensions.cs (3)

90var numberOfSpaces = Math.Max(0, desiredIndentation); 104var numberOfSpaces = Math.Max(0, desiredIndentation); 221return Math.Max(currentIndentation + indentationDelta, 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\BaseIndentationFormattingRule.cs (2)

131=> TextSpan.FromBounds(Math.Max(_span.Start, textSpan.Start), Math.Min(_span.End, textSpan.End));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\TriviaEngine\AbstractTriviaFormatter.cs (8)

574LineColumnRule.IndentationOperations.Absolute => Math.Max(0, rule.Indentation), 576LineColumnRule.IndentationOperations.Given => (trivia2.RawKind == 0) ? this.Spaces : Math.Max(0, _indentation), 577LineColumnRule.IndentationOperations.Follow => Math.Max(0, lineColumnBeforeTrivia1.Column), 586LineColumnRule.SpaceOperations.Preserve => Math.Max(rule.Spaces, existingWhitespaceBetween.Spaces), 587LineColumnRule.SpaceOperations.Force => Math.Max(rule.Spaces, 0), 594var adjustedRuleLines = Math.Max(0, rule.Lines - GetTrailingLinesAtEndOfTrivia1(lineColumnAfterTrivia1)); 596return (rule.LineOperation == LineColumnRule.LineOperations.Preserve) ? Math.Max(adjustedRuleLines, existingWhitespaceBetween.Lines) : adjustedRuleLines; 745return new TextSpan(Math.Min(this.StartPosition + i + 1, this.EndPosition), 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Indentation\AbstractIndentation.Indenter.cs (1)

248=> Math.Min(Root.EndOfFileToken.FullSpan.Start, position);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Log\Logger.LogBlock.cs (1)

17private static readonly ObjectPool<RoslynLogBlock> s_pool = new(() => new RoslynLogBlock(s_pool!), Math.Min(Environment.ProcessorCount * 8, 256));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.WordSpanEnumerator.cs (1)

70Current = TextSpan.FromBounds(Current.End, Math.Min(_nameSpan.End, nextWordSeparator));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (1)

372var segmentLength = Math.Min(buffer.Length, spanLength - offset);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\HeaderFacts\AbstractHeaderFacts.cs (1)

92return Math.Min(afterAttributesToken.Span.Start, node.Span.End);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (1)

459var startOfNodeWithoutAttributes = Math.Min(afterAttributesToken.Span.Start, endOfNode);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.Builder.cs (3)

132var edges = ImmutableArray.CreateBuilder<Edge>(Math.Max(0, _builderNodes.Length - 1)); 153var end = start + Math.Min(edgeCount, CompactEdgeAllocationSize); 263var end = start + Math.Min(currentNode.EdgeCount, CompactEdgeAllocationSize);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EditDistance.cs (3)

482threshold = Math.Min(threshold, targetLength); 498var jStart = Math.Max(1, i - offset); 499var jEnd = Math.Min(targetLength, i + minimumEditCount + offset);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\RoslynParallel.NetFramework.cs (1)

99rval = (rval == -1) ? schedulerMax : Math.Min(schedulerMax, rval);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SerializableBytes.cs (5)

45var count = (int)Math.Min(ChunkSize, length - i); 196var copyCount = Math.Min(Math.Min(ChunkSize - currentOffset, count), (int)(length - position)); 232var copyCount = Math.Min(chunk.Length, count); 383var writeCount = Math.Min(ChunkSize - currentOffset, countLeft);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\StringEscapeEncoder.cs (1)

21var index = prefixIndex >= 0 && prohibitIndex >= 0 ? Math.Min(prefixIndex, prohibitIndex)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\WordSimilarityChecker.cs (2)

113if (Math.Abs(_source.Length - candidateText.Length) <= _threshold) 142var lengthDifference = Math.Abs(originalText.Length - candidateText.Length);

src\Analyzers\Core\CodeFixes\AddExplicitCast\Fixer.cs (1)

134var parameterIndex = Math.Min(i, parameters.Length - 1);

src\Analyzers\Core\CodeFixes\AddExplicitCast\InheritanceDistanceComparer.cs (1)

72distance = Math.Min(GetInheritanceDistanceRecursive(baseType, interfaceType), distance);

src\Analyzers\Core\CodeFixes\AliasAmbiguousType\AbstractAliasAmbiguousTypeCodeFixProvider.cs (1)

88for (int i = 0, n = Math.Min(t1NameSegments.Length, t2NameSegments.Length); i < n; i++)

Extensions\IEnumerableExtensions.cs (3)

960TSource[] chunk = new ReadOnlySpan<TSource>(source, index, Math.Min(size, source.Length - index)).ToArray(); 976int arraySize = Math.Min(size, 4); 993arraySize = (int)Math.Min((uint)size, 2 * (uint)array.Length);

Internal\HashHelpers.cs (1)

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

Segmented\SegmentedArray.cs (10)

494var currentSegmentLength = Math.Min(remainingInSegment, _length); 503var currentSegmentLength = Math.Min(SegmentedArrayHelper.GetSegmentSize<T>(), _length - _completed); 598var currentSegmentLength = Math.Min(Math.Min(remainingInFirstSegment, remainingInSecondSegment), _length - _completed); 646var currentSegmentLength = Math.Min(Math.Min(remainingInFirstSegment, remainingInSecondSegment), _length - _completed); 736_current = segment.AsMemory().Slice(offset, Math.Min(remainingInSegment, _length)); 743_current = segment.AsMemory().Slice(0, Math.Min(SegmentedArrayHelper.GetSegmentSize<T>(), _length - _completed)); 785_current = segment.AsMemory().Slice(offset, Math.Min(remainingInSegment, _length)); 792_current = segment.AsMemory().Slice(0, Math.Min(SegmentedArrayHelper.GetSegmentSize<T>(), _length - _completed));

Segmented\SegmentedList`1.cs (1)

544var newSegmentCount = oldSegmentCount + Math.Max(1, oldSegmentCount >> segmentGrowthShiftValue);

Binder\Binder.cs (2)

952var lastSize = Math.Min(last.Length, 12); 953snippet = first.Substring(0, Math.Min(first.Length, 12)) + " ... " + last.Substring(last.Length - lastSize, lastSize);

Binder\Binder_Deconstruct.cs (1)

351var matchCount = Math.Min(variables.Count, foundTypes.Length);

Binder\Binder_Expressions.cs (1)

4429int?[] knownSizes = new int?[Math.Max(rank, numSizes)];

Binder\DecisionDagBuilder.cs (2)

536int count = Math.Min(method.ParameterCount - extensionExtra, recursive.Deconstruction.Length); 557int count = Math.Min(elementTypes.Length, recursive.Deconstruction.Length);

Binder\Semantics\OverloadResolution\MethodTypeInference.cs (1)

168private int NumberArgumentsToProcess => System.Math.Min(_arguments.Length, _formalParameterTypes.Length);

BoundTree\UnboundLambda.cs (2)

940var numParametersToCheck = Math.Min(targetParameterTypes.Length, ParameterCount); 1422for (int i = 0, n = Math.Min(nx, ny); i < n; i++)

CodeGen\EmitArrayInitializer.cs (1)

282int thresholdCnt = Math.Max(3, (initCount / 3));

CodeGen\EmitStackAllocInitializer.cs (1)

151int thresholdCnt = Math.Max(3, (initCount / 3));

Compilation\CSharpSemanticModel.cs (1)

1293return Math.Max(token.SpanStart, fullStart);

Compiler\DocumentationCommentCompiler.cs (1)

1084int minLength = Math.Min(str1.Length, str2.Length);

Emitter\EditAndContinue\CSharpDefinitionMap.cs (1)

153int slotCount = Math.Min(localSlots.Length, slotMetadata.Length);

FlowAnalysis\NullableWalker.cs (3)

8764Debug.Assert(values.Length == (useRestField ? Math.Min(tupleType.TupleElements.Length, NamedTypeSymbol.ValueTupleRestPosition) : tupleType.TupleElements.Length)); 8772n = Math.Min(n, NamedTypeSymbol.ValueTupleRestPosition - 1); 12932int n = Math.Min(Capacity, 8);

FlowAnalysis\NullableWalker_Patterns.cs (1)

199for (int i = 0, n = Math.Min(rp.Deconstruction.Length, elements.IsDefault ? 0 : elements.Length); i < n; i++)

Lowering\LocalRewriter\LocalRewriter.DecisionDagRewriter.ValueDispatchNode.cs (5)

109Debug.Assert(Math.Abs(l - r) <= 1); 113_height = Math.Max(l, r) + 1; 117Debug.Assert(_height < 2 * Math.Log(_weight)); 162Debug.Assert(Math.Abs(left.Height - right.Height) <= 2); 251Debug.Assert(Math.Abs(left.Height - right.Height) < 2);

Lowering\StateMachineRewriter\ResumableStateMachineStateAllocator.cs (1)

78=> _matchedStateCount < Math.Abs((_slotAllocator?.GetFirstUnusedStateMachineState(_increasing) ?? _firstState) - _firstState);

Parser\Blender.cs (4)

125var start = Math.Max(Math.Min(changeRange.Span.Start, lastCharIndex), 0); 136start = Math.Max(0, token.Position - 1); 152start = Math.Max(start - column, 0);

Parser\LanguageParser_InterpolatedString.cs (2)

222currentIndex = Math.Min(currentIndex, lineStartPosition + indentationWhitespace.Length); 299for (int i = 0, n = Math.Min(currentLineWhitespace.Length, indentationLineWhitespace.Length); i < n; i++)

Parser\Lexer_RawStringLiteral.cs (2)

371_builder.Append(currentLineWhitespace, startIndex: indentationWhitespace.Length, count: Math.Max(0, currentLineWhitespace.Length - indentationWhitespace.Length)); 396for (int i = 0, n = Math.Min(currentLineWhitespace.Length, indentationLineWhitespace.Length); i < n; i++)

Parser\QuickScanner.cs (1)

198n = Math.Min(n, i + MaxCachedTokenSize);

Parser\SlidingTextWindow.cs (3)

183int amountToRead = Math.Min(_text.Length, position + _characterWindow.Length) - position; 184amountToRead = Math.Max(amountToRead, 0); 231int amountToRead = Math.Min(_textEnd - (_basis + _characterWindowCount),

Parser\SyntaxParser.cs (1)

141var size = Math.Min(CachedTokenArraySize, this.lexer.TextWindow.Text.Length / 2);

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.TemplateSymbol.cs (1)

192int displayCount = Math.Min(this.Properties.Length, 10);

Symbols\Tuples\TupleTypeSymbol.cs (1)

800int fieldsPerType = Math.Min(arity, ValueTupleRestPosition - 1);

Syntax\SyntaxNodeRemover.cs (2)

76start = Math.Min(start, span.Start); 77end = Math.Max(end, span.End);

Syntax\SyntaxNormalizer.cs (1)

164count = Math.Max(count - _initialDepth, 0);

Syntax\SyntaxReplacer.cs (2)

152start = Math.Min(start, span.Start); 153end = Math.Max(end, span.End);

Syntax\SyntaxTreeDiagnosticEnumerator.cs (2)

63var spanStart = Math.Min(_position - leadingWidthAlreadyCounted + sdi.Offset, length); 64var spanWidth = Math.Min(spanStart + sdi.Width, length) - spanStart;

Utilities\ValueSetFactory.IntTC.cs (1)

75return Math.Abs((random.Next() << 10) ^ random.Next());

Utilities\ValueSetFactory.NonNegativeIntValueSetFactory.cs (2)

41return new NumericValueSet<int>(Math.Max(0, value + 1), int.MaxValue, tc); 43return new NumericValueSet<int>(Math.Max(0, value), int.MaxValue, tc);

src\Analyzers\CSharp\Analyzers\UsePatternMatching\UsePatternMatchingHelpers.cs (1)

78requiredLanguageVersion = (LanguageVersion)Math.Max((int)requiredLanguageVersion, (int)LanguageVersion.CSharp9);

src\Analyzers\CSharp\Analyzers\UseUtf8StringLiteral\UseUtf8StringLiteralDiagnosticAnalyzer.cs (1)

199var length = Math.Min(arrayCreationElements.Length - startIndex, 4);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Engine\Trivia\TriviaDataFactory.FormattedComplexTrivia.cs (2)

35this.LineBreaks = Math.Max(0, lineBreaks); 36this.Spaces = Math.Max(0, spaces);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Rules\ElasticTriviaFormattingRule.cs (2)

165var line = Math.Max(LineBreaksAfter(previousToken, currentToken), operation.Line); 301return CreateAdjustSpacesOperation(Math.Max(0, operation.Space), AdjustSpacesOption.ForceSpaces);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SyntaxFacts\CSharpSyntaxFacts.cs (1)

706position = Math.Min(position, end - 1);

src\Analyzers\CSharp\CodeFixes\ConvertNamespace\ConvertNamespaceTransform.cs (1)

205using var _ = ArrayBuilder<TextChange>.GetInstance(Math.Max(0, closeBraceLine - openBraceLine - 1), out var changes);

src\Analyzers\CSharp\CodeFixes\MakeMemberRequired\CSharpMakeMemberRequiredCodeFixProvider.cs (1)

70var minimalAccessibility = (Accessibility)Math.Min((int)propertySymbol.DeclaredAccessibility, (int)setMethod.DeclaredAccessibility);

InlineRename\CSharpEditorInlineRenameService.cs (6)

124var fallbackStartLine = Math.Max(0, documentText.Lines.GetLineFromPosition(fallbackSpan.Start).LineNumber - NumberOfContextLines); 125var fallbackEndLine = Math.Min(documentText.Lines.Count - 1, documentText.Lines.GetLineFromPosition(fallbackSpan.End).LineNumber + NumberOfContextLines); 131endLine = Math.Min(documentText.Lines.Count - 1, fallbackEndLine + excessAtStart); 136startLine = Math.Max(0, fallbackStartLine - excessAtEnd); 152startLine = Math.Max(0, documentText.Lines.GetLineFromPosition(fallbackSpan.Start).LineNumber - NumberOfContextLines); 153endLine = Math.Min(documentText.Lines.Count - 1, documentText.Lines.GetLineFromPosition(fallbackSpan.End).LineNumber + NumberOfContextLines);

StringCopyPaste\AbstractPasteProcessor.cs (1)

161ts => Math.Max(

StringCopyPaste\KnownSourcePasteProcessor.cs (1)

247dollarSignCount = Math.Max(1, dollarSignCount);

StringCopyPaste\StringCopyPasteHelpers.cs (2)

208longestCount = Math.Max(longestCount, endQuoteIndex - currentIndex); 530for (var n = Math.Min(commonIndentPrefix.Length, lineWhitespaceSpan.Length); commonPrefixLength < n; commonPrefixLength++)

TextStructureNavigation\CSharpTextStructureNavigatorProvider.cs (2)

100var end = Math.Max(contentStart, token.Span.End); 119contentEnd = Math.Max(contentStart, contentEnd);

Emit\CompilationEmitTests.cs (3)

3883for (int i = 0; i < System.Math.Max(expectedGlobalMembers.Length, actualGlobalMembers.Length); i++) 3905for (int i = 0; i < System.Math.Max(expectedAMembers.Length, actualAMembers.Length); i++) 3913for (int i = 0; i < System.Math.Max(expectedBMembers.Length, actualBMembers.Length); i++)

Semantics\PatternMatchingTests.cs (2)

4908int dt = (int)Math.Abs(DateTime.Now.Ticks % 1000000000); 4921int dt = (int)Math.Abs(DateTime.Now.Ticks % 1000000000);

EndToEndTests.cs (1)

718var interfacesNumber = Math.Max(overloads1Number, overloads2Number);

BraceCompletion\AbstractCurlyBraceOrBracketCompletionService.cs (1)

253var spanToFormat = TextSpan.FromBounds(Math.Max(startPoint, 0), endPoint);

ChangeSignature\ChangeSignatureFormattingRule.cs (1)

46span = TextSpan.FromBounds(Math.Max(baseToken.Span.End, span.Start), span.End);

ChangeSignature\CSharpChangeSignatureService.cs (1)

123var token = root.FindToken(position != tree.Length ? position : Math.Max(0, position - 1));

ConvertToRawString\ConvertInterpolatedStringToRawStringCodeRefactoringProvider.cs (4)

406var quoteDelimiterCount = Math.Max(3, longestQuoteSequence + 1); 426longestQuoteSequence = Math.Max(longestQuoteSequence, GetLongestQuoteSequence(characters)); 427longestBraceSequence = Math.Max(longestBraceSequence, GetLongestBraceSequence(characters)); 681var length = Math.Min(leadingWhitespace1.Length, leadingWhitespace2.Length);

ConvertToRawString\ConvertRegularStringToRawStringCodeRefactoringProvider.cs (3)

183var quoteDelimiterCount = Math.Max(3, longestQuoteSequence + 1); 210var quoteDelimiterCount = Math.Max(3, longestQuoteSequence + 1); 322var length = Math.Min(leadingWhitespace1.Length, leadingWhitespace2.Length);

ConvertToRawString\ConvertToRawStringHelpers.cs (2)

136=> Math.Max(GetLongestCharacterSequence(characters, '{'), GetLongestCharacterSequence(characters, '}')); 147longestSequence = Math.Max(longestSequence, j - i);

EditAndContinue\SyntaxComparer.cs (2)

1606oldToken.Text, Math.Min(oldToken.Text.Length, LongestCommonSubsequence.MaxSequenceLengthForDistanceCalculation), 1607newToken.Text, Math.Min(newToken.Text.Length, LongestCommonSubsequence.MaxSequenceLengthForDistanceCalculation));

EmbeddedLanguages\CSharpTestEmbeddedLanguageClassifier.cs (2)

162nestedAnonymousSpanCount = Math.Max(0, nestedAnonymousSpanCount - 1); 168nestedNamedSpanCount = Math.Max(0, nestedNamedSpanCount - 1);

ImplementInterface\CSharpImplementExplicitlyCodeRefactoringProvider.cs (1)

157for (int i = 0, n = Math.Max(implParameters.Length, interfaceParameters.Length); i < n; i++)

IntroduceVariable\CSharpIntroduceVariableService_IntroduceField.cs (2)

115index = Math.Min(index, firstChangeIndex); 154index = Math.Min(index, firstChangeIndex);

IntroduceVariable\CSharpIntroduceVariableService_IntroduceLocal.cs (1)

477return Math.Min(earliestLocalFunctionCallIndex, firstStatementAffectedIndex);

src\Analyzers\CSharp\Analyzers\UsePatternMatching\UsePatternMatchingHelpers.cs (1)

78requiredLanguageVersion = (LanguageVersion)Math.Max((int)requiredLanguageVersion, (int)LanguageVersion.CSharp9);

src\Analyzers\CSharp\Analyzers\UseUtf8StringLiteral\UseUtf8StringLiteralDiagnosticAnalyzer.cs (1)

199var length = Math.Min(arrayCreationElements.Length - startIndex, 4);

src\Analyzers\CSharp\CodeFixes\ConvertNamespace\ConvertNamespaceTransform.cs (1)

205using var _ = ArrayBuilder<TextChange>.GetInstance(Math.Max(0, closeBraceLine - openBraceLine - 1), out var changes);

src\Analyzers\CSharp\CodeFixes\MakeMemberRequired\CSharpMakeMemberRequiredCodeFixProvider.cs (1)

70var minimalAccessibility = (Accessibility)Math.Min((int)propertySymbol.DeclaredAccessibility, (int)setMethod.DeclaredAccessibility);

EditAndContinue\SyntaxComparerTests.cs (8)

95Assert.Equal(0.67, Math.Round(distance, 2)); 105Assert.Equal(0.33, Math.Round(distance, 2)); 112Assert.Equal(0.33, Math.Round(distance, 2)); 119Assert.Equal(1, Math.Round(distance, 2)); 129Assert.Equal(0, Math.Round(distance, 2)); 135Assert.Equal(0, Math.Round(distance, 2)); 141Assert.Equal(0, Math.Round(distance, 2)); 147Assert.Equal(0, Math.Round(distance, 2));

Semantics\ConstantTests.cs (2)

4019floatConst = ConstantValue.Create(Math.Round(1f / 3f, 5)), 4020doubleConst = ConstantValue.Create(Math.Round((double)1 / 3, 8)),

Symbols\CompilationCreationTests.cs (4)

51Assert.Equal(Math.Sign(compilation.CompareSyntaxTreeOrdering(expectedSyntaxTrees[i], expectedSyntaxTrees[j])), Math.Sign(i.CompareTo(j))); 60Assert.Equal(Math.Sign(compilation.CompareSourceLocations(types[i].Locations[0], types[j].Locations[0])), Math.Sign(i.CompareTo(j)));

Symbols\Source\CompletionTests.cs (1)

123Parallel.For(0, Math.Max(1, Environment.ProcessorCount - 1), t =>

Diagnostics\LineSpanDirectiveTests.cs (1)

501return Math.Min(line.Start + position.Character, line.End);

Extensions.cs (1)

103for (int i = 0; i < Math.Max(thisRefs.Length, thatRefs.Length); i++)

Formatting\CSharpSyntaxFormattingService.cs (2)

46var token = documentSyntax.Root.FindToken(Math.Max(0, caretPosition - 1), findInsideTrivia: true); 79var token = root.FindToken(Math.Max(0, caretPosition - 1), findInsideTrivia: true);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Engine\Trivia\TriviaDataFactory.FormattedComplexTrivia.cs (2)

35this.LineBreaks = Math.Max(0, lineBreaks); 36this.Spaces = Math.Max(0, spaces);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Rules\ElasticTriviaFormattingRule.cs (2)

165var line = Math.Max(LineBreaksAfter(previousToken, currentToken), operation.Line); 301return CreateAdjustSpacesOperation(Math.Max(0, operation.Space), AdjustSpacesOption.ForceSpaces);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SyntaxFacts\CSharpSyntaxFacts.cs (1)

706position = Math.Min(position, end - 1);

CommentSelection\AbstractCommentSelectionBase.cs (1)

214indentToCommentAt = Math.Min(indentToCommentAt, firstNonWhitespaceOnLine);

InlineDiagnostics\AbstractDiagnosticsTaggerProvider.cs (5)

124var length = Math.Min(Math.Max(span.Length, minimumLength), maximumLength); 127var start = Math.Max(0, Math.Min(span.Start, snapshot.Length - length)); 130return new SnapshotSpan(snapshot, start, Math.Min(start + length, snapshot.Length) - start);

InlineDiagnostics\InlineDiagnosticsAdornmentManager.cs (1)

173? Math.Max(lineView.Right, lineView.LineTransform.Right)

InlineDiagnostics\InlineDiagnosticsTag.cs (1)

83var lineHeight = Math.Floor(format.Typeface.FontFamily.LineSpacing * block.FontSize);

InlineRename\UI\Adornment\RenameFlyout.xaml.cs (3)

148MinWidth = Math.Min(DefaultMinWidth, _textView.ViewportWidth); 150Canvas.SetTop(this, Math.Max(0, top)); 151Canvas.SetLeft(this, Math.Max(0, left));

IWpfDifferenceViewerExtensions.cs (1)

112_width = Math.Max(textView.MaxTextRightCoordinate * (textView.ZoomLevel / 100), _minWidth); // Width of the widest line.

Shared\Extensions\IProjectionBufferFactoryServiceExtensions.cs (3)

90var finalSpanStart = Math.Max(line.Start, span.Start); 91var finalSpanEnd = Math.Min(line.EndIncludingLineBreak, span.End); 158? Math.Min(indentationColumn.Value, line.GetColumnOfFirstNonWhitespaceCharacterOrEndOfLine(editorOptions))

Shared\Utilities\CommonFormattingHelpers.cs (1)

38var previousLine = snapshot.GetLineFromLineNumber(Math.Max(currentLine.LineNumber - 1, 0));

SignatureHelp\Controller.cs (2)

99Math.Max(Math.Min(triggerSpan.End, GetCaretPointInViewBuffer().Position), triggerSpan.Start)));

StringIndentation\StringIndentationAdornmentManager.VisibleBlock.cs (1)

61var x = Math.Floor(bounds.Right - (anchorPointLine.VirtualSpaceWidth / 2));

Tagging\AsynchronousViewportTaggerProvider.SingleViewportTaggerProvider.cs (2)

87startLine = Math.Max(startLine - extraLines, 0); 88endLine = Math.Min(endLine + extraLines, snapshot.LineCount - 1);

Classification\ClassificationTestHelper.cs (1)

39var max = Math.Max(expectedClassificationList.Count, actualClassificationList.Count);

KeywordHighlighting\AbstractKeywordHighlighterTests.cs (1)

70for (var j = 0; j < Math.Max(highlightSpans.Count, expectedHighlightSpans.Count); j++)

EmbeddedLanguages\StackFrame\StackFrameParserTests.Utilities.cs (2)

119var start = Math.Max(0, index - 10); 120var end = Math.Min(index, originalText.Length - 1);

MethodContextReuseConstraints.cs (4)

73_endOffsetExclusive = Math.Min(_endOffsetExclusive, scope.StartOffset); 77_startOffset = Math.Max(_startOffset, scope.EndOffsetExclusive); 81_startOffset = Math.Max(_startOffset, scope.StartOffset); 82_endOffsetExclusive = Math.Min(_endOffsetExclusive, scope.EndOffsetExclusive);

PDB\MethodDebugInfo.Portable.cs (4)

155reuseSpanEnd = Math.Min(reuseSpanEnd, (uint)scope.StartOffset); 162reuseSpanStart = Math.Max(reuseSpanStart, (uint)scope.EndOffset); 167reuseSpanStart = Math.Max(reuseSpanStart, (uint)scope.StartOffset); 168reuseSpanEnd = Math.Min(reuseSpanEnd, (uint)scope.EndOffset);

src\Compilers\Core\Portable\CaseInsensitiveComparison.cs (2)

111int len = Math.Min(str1.Length, str2.Length); 127int len = Math.Min(str1.Length, str2.Length);

src\ExpressionEvaluator\Core\Source\ResultProvider\Expansion\Expansion.cs (3)

54startIndex3 = Math.Max(startIndex1, startIndex2); 55int endIndex3 = Math.Min(startIndex1 + count1, startIndex2 + count2); 56count3 = Math.Max(endIndex3 - startIndex3, 0);

src\ExpressionEvaluator\Core\Source\ResultProvider\Expansion\TupleExpansion.cs (1)

283int n = Math.Min(cardinality, TypeHelpers.TupleFieldRestPosition - 1);

src\ExpressionEvaluator\Core\Source\ResultProvider\Formatter.TypeNames.cs (1)

405int nFields = Math.Min(nTypeArgs, TypeHelpers.TupleFieldRestPosition - 1);

src\ExpressionEvaluator\Core\Source\ResultProvider\Helpers\TypeHelpers.cs (1)

493int n = Math.Min(cardinality, TupleFieldRestPosition - 1);

src\ExpressionEvaluator\Core\Source\ResultProvider\Expansion\Expansion.cs (3)

54startIndex3 = Math.Max(startIndex1, startIndex2); 55int endIndex3 = Math.Min(startIndex1 + count1, startIndex2 + count2); 56count3 = Math.Max(endIndex3 - startIndex3, 0);

src\ExpressionEvaluator\Core\Source\ResultProvider\Expansion\TupleExpansion.cs (1)

283int n = Math.Min(cardinality, TypeHelpers.TupleFieldRestPosition - 1);

src\ExpressionEvaluator\Core\Source\ResultProvider\Formatter.TypeNames.cs (1)

405int nFields = Math.Min(nTypeArgs, TypeHelpers.TupleFieldRestPosition - 1);

src\ExpressionEvaluator\Core\Source\ResultProvider\Helpers\TypeHelpers.cs (1)

493int n = Math.Min(cardinality, TupleFieldRestPosition - 1);

ClassifiedSpansAndHighlightSpanFactory.cs (1)

53return TextSpan.FromBounds(Math.Min(firstNonWhitespacePosition, referenceSpan.Start), sourceLine.End);

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.cs (1)

279var spanEnd = Math.Max(startToken.Span.End, span.End);

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.RemoveSuppressionCodeAction_Pragma.cs (1)

209start: Math.Max(0, trivia.Span.Start - 1),

CodeLens\CodeLensReferencesService.cs (1)

95? Math.Min(progress.ReferencesCount, progress.SearchCap)

Completion\Providers\Scripting\AbstractDirectivePathCompletionProvider.cs (2)

122var startIndex = Math.Max(afterLastSlashIndex, afterFirstQuote); 145position = Math.Min(position, text.Length - 1);

Diagnostics\Service\DocumentAnalysisExecutor.cs (2)

290return TextSpan.FromBounds(Math.Min(startSpan.Start, endSpan.Start), Math.Max(startSpan.End, endSpan.End));

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (2)

729lineText = text.ToString(TextSpan.FromBounds(diagnostic.Span.Start, Math.Min(diagnostic.Span.Start + 120, line.End))); 1874if (areSimilar != null && matchCount < Math.Min(oldNodes.Count, newNodes.Count))

EditAndContinue\EditSession.cs (1)

221for (var i = 0; i < Math.Min(oldLineCount, newLineCount); i++)

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingIdleProcessor.cs (1)

106var delayTimeSpan = TimeSpan.FromMilliseconds(Math.Max(s_minimumDelay.TotalMilliseconds, timeLeft.TotalMilliseconds));

ExternalAccess\VSTypeScript\VSTypeScriptTaskListService.cs (2)

40var textSpan = new TextSpan(Math.Min(text.Length, Math.Max(0, d.Position)), 0);

ExtractMethod\SelectionValidator.cs (2)

101? Math.Min(initialSelectionInfo.FirstTokenInOriginalSpan.SpanStart, adjustedSpan.Start) 105? Math.Max(initialSelectionInfo.LastTokenInOriginalSpan.Span.End, adjustedSpan.End)

IntroduceUsingStatement\AbstractIntroduceUsingStatementCodeRefactoringProvider.cs (1)

420endOfUsingStatementIndex = Math.Max(endOfUsingStatementIndex, lastVariableUsageIndex[localSymbol]);

NavigateTo\RoslynNavigateToItem.cs (1)

263var maxCommon = Math.Min(activeFolders.Count, itemFolders.Count);

QuickInfo\IndentationHelper.cs (3)

60var spanBeforeDeletion = TextSpan.FromBounds(span.Start, Math.Min(span.End, deletion.Start)); 69span = TextSpan.FromBounds(Math.Min(deletion.End, span.End), span.End); 124? Math.Min(currentValue, line.GetColumnOfFirstNonWhitespaceCharacterOrEndOfLine(tabSize))

RelatedDocuments\AbstractRelatedDocumentsService.cs (1)

97IteratePotentialTypeNodes(root).OrderBy(t => Math.Abs(t.expression.SpanStart - position)),

SemanticSearch\QueryExecutionContext.cs (1)

266skippedFrameCount = Math.Max(0, displayFramesEnd - StackDisplayDepthLimit);

Snippets\RoslynLSPSnippetConverter.cs (5)

133startPosition = Math.Min(startPosition, placeholders.Min(placeholder => placeholder.StartingPositions.Min())); 134endPosition = Math.Max(endPosition, placeholders.Max(placeholder => placeholder.StartingPositions.Max())); 137startPosition = Math.Min(startPosition, caretPosition); 138endPosition = Math.Max(endPosition, caretPosition); 140startPosition = Math.Min(startPosition, triggerLocation);

src\Analyzers\Core\Analyzers\FileHeaders\AbstractFileHeaderHelper.cs (1)

63fileHeaderStart = Math.Min(trivia.FullSpan.Start, fileHeaderStart);

src\Analyzers\Core\Analyzers\RemoveUnnecessaryParentheses\AbstractRemoveUnnecessaryParenthesesDiagnosticAnalyzer.cs (1)

134var textSpanEndPosition = Math.Min(parenthesizedExpressionLocation.SourceSpan.End, expressionFirstLine.Span.End);

src\Analyzers\Core\CodeFixes\AddExplicitCast\Fixer.cs (1)

134var parameterIndex = Math.Min(i, parameters.Length - 1);

src\Analyzers\Core\CodeFixes\AddExplicitCast\InheritanceDistanceComparer.cs (1)

72distance = Math.Min(GetInheritanceDistanceRecursive(baseType, interfaceType), distance);

src\Analyzers\Core\CodeFixes\AliasAmbiguousType\AbstractAliasAmbiguousTypeCodeFixProvider.cs (1)

88for (int i = 0, n = Math.Min(t1NameSegments.Length, t2NameSegments.Length); i < n; i++)

EditAndContinue\ActiveStatementsDescription.cs (1)

53var activeStatementCount = Math.Max(OldStatements.Length, (newActiveStatementMarkers.Length == 0) ? -1 : newActiveStatementMarkers.Max(m => m.Id));

Interactive\Core\InteractiveHost.Service.cs (1)

779for (int i = 0, n = Math.Min(diagnostics.Length, MaxErrorCount); i < n; i++)

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (2)

566var maxSearchIndex = Math.Min(directoryPathParts.Length, fullPathParts.Length); 648return PathsEqual(path1, path2, Math.Max(path1.Length, path2.Length));

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (1)

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

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (3)

960TSource[] chunk = new ReadOnlySpan<TSource>(source, index, Math.Min(size, source.Length - index)).ToArray(); 976int arraySize = Math.Min(size, 4); 993arraySize = (int)Math.Min((uint)size, 2 * (uint)array.Length);

src\Dependencies\Collections\Internal\HashHelpers.cs (1)

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

src\Dependencies\Collections\Segmented\SegmentedArray.cs (10)

494var currentSegmentLength = Math.Min(remainingInSegment, _length); 503var currentSegmentLength = Math.Min(SegmentedArrayHelper.GetSegmentSize<T>(), _length - _completed); 598var currentSegmentLength = Math.Min(Math.Min(remainingInFirstSegment, remainingInSecondSegment), _length - _completed); 646var currentSegmentLength = Math.Min(Math.Min(remainingInFirstSegment, remainingInSecondSegment), _length - _completed); 736_current = segment.AsMemory().Slice(offset, Math.Min(remainingInSegment, _length)); 743_current = segment.AsMemory().Slice(0, Math.Min(SegmentedArrayHelper.GetSegmentSize<T>(), _length - _completed)); 785_current = segment.AsMemory().Slice(offset, Math.Min(remainingInSegment, _length)); 792_current = segment.AsMemory().Slice(0, Math.Min(SegmentedArrayHelper.GetSegmentSize<T>(), _length - _completed));

src\Dependencies\Collections\Segmented\SegmentedList`1.cs (1)

544var newSegmentCount = oldSegmentCount + Math.Max(1, oldSegmentCount >> segmentGrowthShiftValue);

Extensions\ProtocolConversions.cs (2)

520Math.Min(text.Length, span.Start), 521Math.Min(text.Length, span.End));

Features\UnifiedSuggestions\UnifiedSuggestedActionSetComparer.cs (2)

46var startsDistance = Math.Abs(a.Start - b.Start); 47var endsDistance = Math.Abs(a.End - b.End);

Handler\OnAutoInsert\OnAutoInsertHandler.cs (1)

191desiredCaretLinePosition = new LinePosition(desiredCaretLinePosition.Line, Math.Min(desiredCaretLinePosition.Character, caretLine.End));

Handler\SemanticTokens\SemanticTokensHelpers.cs (1)

186textSpan = TextSpan.FromBounds(Math.Min(absoluteStart, line.End), line.End);

Handler\SpellCheck\AbstractSpellCheckingHandler.cs (1)

176var batchEnd = Math.Min(batchStart + chunkSize, spans.Length);

src\RoslynAnalyzers\Utilities\Compiler\SmallDictionary.cs (3)

178return 1 + Math.Max(a, b); 303Math.Abs(a - b) >= 2) 308return 1 + Math.Max(a, b);

Services\DiagnosticAnalyzer\PerformanceQueue.cs (3)

119var stddev = Math.Sqrt(data.Select(ms => Math.Pow(ms - average, 2)).Average()); 120var squareLength = Math.Sqrt(data.Count);

AbstractResxGenerator.cs (1)

903var charactersToRead = Math.Min(remaining, count);

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.AssemblyMetricData.cs (1)

59depthOfInheritance = Math.Max(child.DepthOfInheritance.GetValueOrDefault(), depthOfInheritance);

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.FieldMetricData.cs (4)

47double computationalComplexityVolume = Math.Max(0.0, Math.Log(computationalComplexityMetrics.Volume)); //avoid Log(0) = -Infinity 48double logEffectiveLinesOfCode = Math.Max(0.0, Math.Log(computationalComplexityMetrics.EffectiveLinesOfCode)); //avoid Log(0) = -Infinity

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.MethodMetricData.cs (4)

58double computationalComplexityVolume = Math.Max(0.0, Math.Log(computationalComplexityMetrics.Volume)); //avoid Log(0) = -Infinity 59double logEffectiveLinesOfCode = Math.Max(0.0, Math.Log(computationalComplexityMetrics.EffectiveLinesOfCode)); //avoid Log(0) = -Infinity

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.NamedTypeMetricData.cs (4)

175double logAvgComputationalComplexityVolume = Math.Max(0.0, Math.Log(avgComputationalComplexityVolume)); //avoid Log(0) = -Infinity 176double logAvgLinesOfCode = Math.Max(0.0, Math.Log(avgEffectiveLinesOfCode)); //avoid Log(0) = -Infinity

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.NamespaceMetricData.cs (1)

57depthOfInheritance = Math.Max(child.DepthOfInheritance.GetValueOrDefault(), depthOfInheritance);

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\ComputationalComplexityMetrics.cs (2)

437=> Length * Math.Max(0.0, Math.Log(Vocabulary, 2));

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (3)

33private static int RoundMetricValue(double value) => (int)Math.Round(value, 0); 37maintIndex = Math.Max(0.0, maintIndex); 93var additionalNewLines = Math.Max(0, GetNewlineCount(declSyntax.GetLeadingTrivia(), leading: true) + GetNewlineCount(declSyntax.GetTrailingTrivia(), leading: false) - 1);

src\RoslynAnalyzers\Utilities\Compiler\SmallDictionary.cs (3)

178return 1 + Math.Max(a, b); 303Math.Abs(a - b) >= 2) 308return 1 + Math.Max(a, b);

Hosting\ObjectFormatter\CommonObjectFormatter.Builder.cs (5)

32_currentLimit = Math.Min(_options.MaximumLineLength, _options.MaximumOutputLength); 55_currentLimit = (int)Math.Min((long)_sb.Length + _options.MaximumLineLength, _options.MaximumOutputLength); 81int length = Math.Min(count, CurrentRemaining); 98count = Math.Min(count, str.Length - start); 99int length = Math.Min(count, CurrentRemaining);

Hosting\ObjectFormatter\CommonObjectFormatter.Visitor.cs (1)

61return new Builder(_builderOptions.WithMaximumOutputLength(Math.Min(_builderOptions.MaximumLineLength, limit)), suppressEllipsis: true);

ScriptExecutionState.cs (1)

162Array.Resize(ref _submissionStates, Math.Max(SubmissionStateCount, _submissionStates.Length * 2));

Assert\AssertEx.cs (3)

456rows[nextRow][j] = Math.Min(dist1, Math.Min(dist2, dist3)); 794var expectedString = join(itemSeparator, expected[..Math.Min(expected.Length, maxDisplayedExpectedEntries)], itemInspector);

Assert\DiffUtil.cs (3)

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

FX\ImmutableArrayTestExtensions.cs (2)

38var buffer = new byte[Math.Min(bufferSize, bytes.Length)]; 43int length = Math.Min(bufferSize, bytes.Length - offset);

Syntax\TokenUtilities.cs (1)

23var max = Math.Min(expectedTokens.Count, actualTokens.Count);

src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (3)

960TSource[] chunk = new ReadOnlySpan<TSource>(source, index, Math.Min(size, source.Length - index)).ToArray(); 976int arraySize = Math.Min(size, 4); 993arraySize = (int)Math.Min((uint)size, 2 * (uint)array.Length);

src\Dependencies\Collections\Internal\HashHelpers.cs (1)

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

src\Dependencies\Collections\Segmented\SegmentedArray.cs (10)

494var currentSegmentLength = Math.Min(remainingInSegment, _length); 503var currentSegmentLength = Math.Min(SegmentedArrayHelper.GetSegmentSize<T>(), _length - _completed); 598var currentSegmentLength = Math.Min(Math.Min(remainingInFirstSegment, remainingInSecondSegment), _length - _completed); 646var currentSegmentLength = Math.Min(Math.Min(remainingInFirstSegment, remainingInSecondSegment), _length - _completed); 736_current = segment.AsMemory().Slice(offset, Math.Min(remainingInSegment, _length)); 743_current = segment.AsMemory().Slice(0, Math.Min(SegmentedArrayHelper.GetSegmentSize<T>(), _length - _completed)); 785_current = segment.AsMemory().Slice(offset, Math.Min(remainingInSegment, _length)); 792_current = segment.AsMemory().Slice(0, Math.Min(SegmentedArrayHelper.GetSegmentSize<T>(), _length - _completed));

src\Dependencies\Collections\Segmented\SegmentedList`1.cs (1)

544var newSegmentCount = oldSegmentCount + Math.Max(1, oldSegmentCount >> segmentGrowthShiftValue);

Collections\BitArrayTests.cs (2)

124var maxCapacity = Math.Max(capacity1, capacity2); 282capacity = Math.Max(capacity, index + 1);

Collections\EnumerableExtensionsTests.cs (2)

48public bool Equals(int x, int y) => Math.Abs(x) == Math.Abs(y);

Collections\HashSet\SegmentedHashSet_Generic_Tests`1.cs (1)

49int root = (int)Math.Sqrt(i);

Collections\HashSet\TestingTypes.cs (5)

158return Math.Abs(x) - Math.Abs(y); 163return Math.Abs(x) == Math.Abs(y); 168return Math.Abs(x);

Collections\ImmutableArrayExtensionsTests.cs (3)

130return Math.Abs(x) == Math.Abs(y); 135return Math.Abs(x);

Collections\TopologicalSortTests.cs (1)

145successors[possibleSort[i]] = randomSubset((int)Math.Sqrt(i), i);

LinePositionTests.cs (4)

80Assert.Equal(-1, Math.Sign(new LinePosition(1, 1).CompareTo(new LinePosition(1, 2)))); 83Assert.Equal(-1, Math.Sign(new LinePosition(1, 2).CompareTo(new LinePosition(2, 1)))); 88Assert.Equal(+1, Math.Sign(new LinePosition(1, 2).CompareTo(new LinePosition(1, 1)))); 91Assert.Equal(+1, Math.Sign(new LinePosition(2, 1).CompareTo(new LinePosition(1, 2))));

RealParserTests.cs (2)

448f = (float)Math.Pow(2.0, i); 467f = (float)Math.Pow(10.0, i);

Text\CompositeTextTests.cs (1)

58for (var sourceTextCount = minSourceTextCount; sourceTextCount <= Math.Min(maxSourceTextCount, contents.Length); sourceTextCount++)

Syntax\SyntaxReplacer.vb (2)

123start = Math.Min(start, span.Start) 124[end] = Math.Max([end], span.End)

Classification\SyntaxClassification\SyntacticChangeRangeComputer.cs (2)

110commonRightWidth = Math.Min(commonRightWidth, oldRootWidth - commonLeftWidth.Value); 111commonRightWidth = Math.Min(commonRightWidth, newRootWidth - commonLeftWidth.Value);

Differencing\LongestCommonSubsequence.cs (2)

122=> 2 * Math.Max(depth, 1) + 1; 396var max = Math.Max(oldLength, newLength);

FindSymbols\FindReferences\DependentProjectsFinder.cs (1)

127projectAndVisibility.visibility = (SymbolVisibility)Math.Min((int)projectAndVisibility.visibility, (int)symbol.GetResultantVisibility());

FindSymbols\FindReferences\FindReferenceCache.cs (1)

206nextIndex = Math.Max(nextIndex, token.SpanStart);

FindSymbols\TopLevelSyntaxTree\DeclaredSymbolInfo.cs (2)

130parameterCount = Math.Min(parameterCount, (byte)Max4BitValue); 131typeParameterCount = Math.Min(typeParameterCount, (byte)Max4BitValue);

PatternMatching\AllLowerCamelCaseMatcher.cs (1)

158var maxHumpMatchLength = Math.Min(maxPatternHumpLength, maxCandidateHumpLength);

Shared\Extensions\FileLinePositionSpanExtensions.cs (4)

47var startColumn = Math.Max(span.Start.Character, 0); 48var endColumn = Math.Max(span.End.Character, 0); 77startColumn = Math.Min(startColumn, lines[startLine].SpanIncludingLineBreak.Length); 78endColumn = Math.Min(endColumn, lines[endLine].SpanIncludingLineBreak.Length);

Shared\Extensions\INamespaceSymbolExtensions.cs (1)

45for (var i = 0; i < Math.Min(names1.Count, names2.Count); i++)

Shared\Extensions\SourceTextExtensions.cs (3)

214var count = Math.Min(buffer.Length, length - offset); 343var totalCharsToRead = Math.Min(count, Length - Position); 352var charsToCopy = Math.Min(chunk.Length - chunkStartOffset, count);

Shared\Utilities\BloomFilter.cs (10)

41var m = Math.Max(1, ComputeM(expectedCount, falsePositiveProbability)); 42var k = Math.Max(1, ComputeK(expectedCount, falsePositiveProbability)); 82var numerator = n * Math.Log(p); 83var denominator = Math.Log(1.0 / Math.Pow(2.0, Math.Log(2.0))); 84return unchecked((int)Math.Ceiling(numerator / denominator)); 93var temp = Math.Log(2.0) * m / n; 94return unchecked((int)Math.Round(temp)); 331return Math.Abs(hash);

Shared\Utilities\DocumentationComment.cs (1)

207maxPrefix = Math.Min(maxPrefix, firstNonWhitespaceOffset.Value);

Shared\Utilities\XmlFragmentParser.cs (1)

198var charCount = Math.Min(src.Length - srcIndex, destCount);

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (2)

566var maxSearchIndex = Math.Min(directoryPathParts.Length, fullPathParts.Length); 648return PathsEqual(path1, path2, Math.Max(path1.Length, path2.Length));

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (1)

465return Math.BigMul(left, right, out lower);

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (1)

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

src\Compilers\Core\Portable\Syntax\SyntaxTreeExtensions.cs (1)

92var n = Math.Min(n1, n2);

src\Compilers\Core\Portable\Text\TextChangeRangeExtensions.cs (1)

224var oldChangeLeadingDeletion = Math.Min(oldChange.Span.Length, oldChangeLeadingInsertion);

src\Dependencies\Collections\Internal\HashHelpers.cs (1)

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

src\Dependencies\Collections\Segmented\SegmentedArray.cs (10)

494var currentSegmentLength = Math.Min(remainingInSegment, _length); 503var currentSegmentLength = Math.Min(SegmentedArrayHelper.GetSegmentSize<T>(), _length - _completed); 598var currentSegmentLength = Math.Min(Math.Min(remainingInFirstSegment, remainingInSecondSegment), _length - _completed); 646var currentSegmentLength = Math.Min(Math.Min(remainingInFirstSegment, remainingInSecondSegment), _length - _completed); 736_current = segment.AsMemory().Slice(offset, Math.Min(remainingInSegment, _length)); 743_current = segment.AsMemory().Slice(0, Math.Min(SegmentedArrayHelper.GetSegmentSize<T>(), _length - _completed)); 785_current = segment.AsMemory().Slice(offset, Math.Min(remainingInSegment, _length)); 792_current = segment.AsMemory().Slice(0, Math.Min(SegmentedArrayHelper.GetSegmentSize<T>(), _length - _completed));

src\Dependencies\Collections\Segmented\SegmentedList`1.cs (1)

544var newSegmentCount = oldSegmentCount + Math.Max(1, oldSegmentCount >> segmentGrowthShiftValue);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\ImmutableIntervalTree`1.cs (1)

198var elementsInLastRowCappedAtMidwayPoint = Math.Min(elementsInLastIncompleteRow, elementsInLastRowIfTreeWerePerfect / 2);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\IntervalTreeAlgorithms`2.cs (2)

146var overlapStart = Math.Max(thisStart, otherStart); 147var overlapEnd = Math.Min(thisEnd, otherEnd);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\MutableIntervalTree`1.Node.cs (1)

35this.Height = 1 + Math.Max(Height(left), Height(right));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (5)

296spans.Add(TextSpan.FromBounds(Math.Max(lastEnd, span1.Start), span1.End)); 307spans.Add(TextSpan.FromBounds(Math.Max(lastEnd, span1.Start), span2.Start)); 334spans.Add(TextSpan.FromBounds(Math.Max(lastEnd, span1.Start), span1.End)); 581end = Math.Max(end, span.End); 617oldEnd = Math.Max(oldEnd, newEnd);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\Common\EmbeddedSyntaxNode.cs (2)

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\Common\EmbeddedSyntaxToken.cs (4)

85Math.Min(LeadingTrivia.Length == 0 ? int.MaxValue : LeadingTrivia[0].GetSpan().Start, 86Math.Min(VirtualChars.Length == 0 ? int.MaxValue : VirtualChars[0].Span.Start, 90Math.Max(LeadingTrivia.Length == 0 ? int.MinValue : LeadingTrivia[^1].GetSpan().End, 91Math.Max(VirtualChars.Length == 0 ? int.MinValue : VirtualChars[^1].Span.End,

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\INamespaceOrTypeSymbolExtensions.cs (1)

43for (var i = 0; i < Math.Min(names1.Count, names2.Count); i++)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\ISymbolExtensions.cs (3)

127if (bestMethod is null || Math.Abs(method.Parameters.Length - parameterCount) < Math.Abs(bestMethod.Parameters.Length - parameterCount)) 497var count = extensionUsedAsInstance ? Math.Max(0, method.Parameters.Length - 1) : method.Parameters.Length;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (2)

305Math.Min(fullSpan.Start, node.SpanStart), 306Math.Max(fullSpan.End, node.Span.End));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\TextSpanExtensions.cs (2)

79var startSegmentEnd = Math.Min(span.End, except.Start); 83var endSegmentStart = Math.Max(span.Start, except.End);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\BottomUpBaseIndentationFinder.cs (2)

173return Math.Max(0, baseIndentation + (indentationLevel + delta) * _indentationSize); 178return Math.Max(0, indentationLevel + extraSpaces);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Engine\AbstractTriviaDataFactory.FormattedWhitespace.cs (2)

21this.LineBreaks = Math.Max(0, lineBreaks); 22this.Spaces = Math.Max(0, indentation);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingExtensions.cs (3)

90var numberOfSpaces = Math.Max(0, desiredIndentation); 104var numberOfSpaces = Math.Max(0, desiredIndentation); 221return Math.Max(currentIndentation + indentationDelta, 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\BaseIndentationFormattingRule.cs (2)

131=> TextSpan.FromBounds(Math.Max(_span.Start, textSpan.Start), Math.Min(_span.End, textSpan.End));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\TriviaEngine\AbstractTriviaFormatter.cs (8)

574LineColumnRule.IndentationOperations.Absolute => Math.Max(0, rule.Indentation), 576LineColumnRule.IndentationOperations.Given => (trivia2.RawKind == 0) ? this.Spaces : Math.Max(0, _indentation), 577LineColumnRule.IndentationOperations.Follow => Math.Max(0, lineColumnBeforeTrivia1.Column), 586LineColumnRule.SpaceOperations.Preserve => Math.Max(rule.Spaces, existingWhitespaceBetween.Spaces), 587LineColumnRule.SpaceOperations.Force => Math.Max(rule.Spaces, 0), 594var adjustedRuleLines = Math.Max(0, rule.Lines - GetTrailingLinesAtEndOfTrivia1(lineColumnAfterTrivia1)); 596return (rule.LineOperation == LineColumnRule.LineOperations.Preserve) ? Math.Max(adjustedRuleLines, existingWhitespaceBetween.Lines) : adjustedRuleLines; 745return new TextSpan(Math.Min(this.StartPosition + i + 1, this.EndPosition), 0);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Indentation\AbstractIndentation.Indenter.cs (1)

248=> Math.Min(Root.EndOfFileToken.FullSpan.Start, position);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Log\Logger.LogBlock.cs (1)

17private static readonly ObjectPool<RoslynLogBlock> s_pool = new(() => new RoslynLogBlock(s_pool!), Math.Min(Environment.ProcessorCount * 8, 256));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyle.WordSpanEnumerator.cs (1)

70Current = TextSpan.FromBounds(Current.End, Math.Min(_nameSpan.End, nextWordSeparator));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (1)

372var segmentLength = Math.Min(buffer.Length, spanLength - offset);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\HeaderFacts\AbstractHeaderFacts.cs (1)

92return Math.Min(afterAttributesToken.Span.Start, node.Span.End);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (1)

459var startOfNodeWithoutAttributes = Math.Min(afterAttributesToken.Span.Start, endOfNode);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\BKTree.Builder.cs (3)

132var edges = ImmutableArray.CreateBuilder<Edge>(Math.Max(0, _builderNodes.Length - 1)); 153var end = start + Math.Min(edgeCount, CompactEdgeAllocationSize); 263var end = start + Math.Min(currentNode.EdgeCount, CompactEdgeAllocationSize);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\EditDistance.cs (3)

482threshold = Math.Min(threshold, targetLength); 498var jStart = Math.Max(1, i - offset); 499var jEnd = Math.Min(targetLength, i + minimumEditCount + offset);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SerializableBytes.cs (5)

45var count = (int)Math.Min(ChunkSize, length - i); 196var copyCount = Math.Min(Math.Min(ChunkSize - currentOffset, count), (int)(length - position)); 232var copyCount = Math.Min(chunk.Length, count); 383var writeCount = Math.Min(ChunkSize - currentOffset, countLeft);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\StringEscapeEncoder.cs (1)

21var index = prefixIndex >= 0 && prohibitIndex >= 0 ? Math.Min(prefixIndex, prohibitIndex)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\WordSimilarityChecker.cs (2)

113if (Math.Abs(_source.Length - candidateText.Length) <= _threshold) 142var lengthDifference = Math.Abs(originalText.Length - candidateText.Length);

TemporaryStorage\TemporaryStorageService.DirectMemoryAccessStreamReader.cs (1)

66count = Math.Min(count, (int)(_end - _position));

Workspace\Solution\Checksum_Factory.cs (1)

124var count = Math.Min(maxStackAllocCount, checksumsCount - checksumsIndex);

src\Compilers\Core\Portable\CaseInsensitiveComparison.cs (2)

111int len = Math.Min(str1.Length, str2.Length); 127int len = Math.Min(str1.Length, str2.Length);

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (2)

566var maxSearchIndex = Math.Min(directoryPathParts.Length, fullPathParts.Length); 648return PathsEqual(path1, path2, Math.Max(path1.Length, path2.Length));

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (1)

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

src\Compilers\Core\Portable\InternalUtilities\ReadOnlyUnmanagedMemoryStream.cs (1)

37int bytesRead = Math.Min(count, _length - _position);

src\Compilers\Core\Portable\InternalUtilities\WeakList.cs (1)

91return Math.Max((baseSize * 2) + 1, MinimalNonEmptySize);

src\Dependencies\Collections\Internal\HashHelpers.cs (1)

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

src\Dependencies\Collections\Segmented\SegmentedArray.cs (10)

494var currentSegmentLength = Math.Min(remainingInSegment, _length); 503var currentSegmentLength = Math.Min(SegmentedArrayHelper.GetSegmentSize<T>(), _length - _completed); 598var currentSegmentLength = Math.Min(Math.Min(remainingInFirstSegment, remainingInSecondSegment), _length - _completed); 646var currentSegmentLength = Math.Min(Math.Min(remainingInFirstSegment, remainingInSecondSegment), _length - _completed); 736_current = segment.AsMemory().Slice(offset, Math.Min(remainingInSegment, _length)); 743_current = segment.AsMemory().Slice(0, Math.Min(SegmentedArrayHelper.GetSegmentSize<T>(), _length - _completed)); 785_current = segment.AsMemory().Slice(offset, Math.Min(remainingInSegment, _length)); 792_current = segment.AsMemory().Slice(0, Math.Min(SegmentedArrayHelper.GetSegmentSize<T>(), _length - _completed));

src\Dependencies\Collections\Segmented\SegmentedList`1.cs (1)

544var newSegmentCount = oldSegmentCount + Math.Max(1, oldSegmentCount >> segmentGrowthShiftValue);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SerializableBytes.cs (5)

45var count = (int)Math.Min(ChunkSize, length - i); 196var copyCount = Math.Min(Math.Min(ChunkSize - currentOffset, count), (int)(length - position)); 232var copyCount = Math.Min(chunk.Length, count); 383var writeCount = Math.Min(ChunkSize - currentOffset, countLeft);

Differencing\TestTreeComparer.cs (1)

28=> Math.Abs((double)left.Value - right.Value) / TestNode.MaxValue;

DataFrame.Arrow.cs (2)

189int numberOfRowsInThisRecordBatch = (int)Math.Min(recordBatchLength, Rows.Count); 198numberOfRowsInThisRecordBatch = (int)Math.Min(numberOfRowsInThisRecordBatch, column.GetMaxRecordBatchLength(numberOfRowsProcessed));

DataFrame.cs (4)

343int shuffleUpperLimit = (int)Math.Min(Int32.MaxValue, Rows.Count); 711longestColumnName = Math.Max(longestColumnName, Columns[i].Name.Length); 714int padding = Math.Max(10, longestColumnName + 1); 721long numberOfRows = Math.Min(Rows.Count, rowsToShow);

DataFrame.IO.cs (1)

425numberOfColumns = Math.Max(numberOfColumns, fields.Length);

DataFrame.Join.cs (4)

57long minLength = Math.Min(Rows.Count, other.Rows.Count); 80long minLength = Math.Min(Rows.Count, other.Rows.Count); 108long newRowCount = Math.Max(Rows.Count, other.Rows.Count); 125long newRowCount = Math.Min(Rows.Count, other.Rows.Count);

DataFrameBuffer.cs (3)

48_memory = new byte[Math.Max(capacity, MinCapacity) * Size]; 83var doubledSize = (int)Math.Min((long)ReadOnlyBuffer.Length * 2, ArrayUtility.ArrayMaxSize); 84var newCapacity = Math.Max(newLength * Size, doubledSize);

DataFrameColumn.cs (1)

440var numberOfRows = Math.Min(Length, rowsToShow);

DataFrameColumns\StringDataFrameColumn.cs (1)

31List<string> buffer = new List<string>((int)Math.Min(MaxCapacity, bufferLen));

DataFrameColumns\VBufferDataFrameColumn.cs (1)

34int bufferLen = (int)Math.Min(MaxCapacity, length - _vBuffers.Count * MaxCapacity);

PrimitiveColumnContainer.cs (2)

160int allocatable = (int)Math.Min(remaining, ReadOnlyDataFrameBuffer<T>.MaxCapacity - originalBufferLength); 373long endIndex = Math.Min(Length, startIndex + length);

PrimitiveDataFrameColumn.cs (1)

215long endIndex = Math.Min(Length, startIndex + length);

PrimitiveDataFrameColumnComputations.cs (120)

DataFrameKernelExtension.cs (1)

56var rowCount = Math.Min(maxRowCount, df.Rows.Count);

src\common\GeneralUtils.cs (1)

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

src\CreateAzureDevOpsFeed.cs (1)

214return project.Substring(0, Math.Min(3, project.Length));

PublishArtifactsInManifestTests.cs (2)

237int bytesToWrite = Math.Min(Math.Min(_streamBytes.Length - _position, count), maxStreamBytesThisCall);

src\ExecWithRetries.cs (1)

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

AzureDevOpsTask.cs (2)

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

TestHelpers\DiffUtil.cs (3)

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

RemoteExecutor.cs (1)

105return 60 * 1000 * Math.Max(failWaitTimeoutMultiplier, 1);

src\Hash.cs (1)

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

src\SignToolTask.cs (1)

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

StringExtensions.cs (1)

49replacementCount = Math.Max(replacementCount, index + 1);

AsyncCollectionAssertsTests.cs (12)

Sdk\ArgumentFormatterTests.cs (3)

134 var floatPI = (float)Math.PI; 146 Assert.Equal(Math.PI.ToString("G17"), ArgumentFormatter.Format(Math.PI));

Functions\AIFunctionFactory.Utilities.cs (1)

120int newCapacity = Math.Max(requiredCapacity, _buffer.Length * 2);

QuantizationEmbeddingGenerator.cs (1)

49var result = new byte[(int)Math.Ceiling(vector.Length / 8.0)];

src\Shared\ServerSentEvents\PooledByteBufferWriter.cs (2)

20_buffer.EnsureAvailableSpace(Math.Max(sizeHint, MinimumBufferSize)); 26_buffer.EnsureAvailableSpace(Math.Max(sizeHint, MinimumBufferSize));

src\Shared\ServerSentEvents\SseParser_1.cs (1)

561buffer = ArrayPool<byte>.Shared.Rent(Math.Max(minimumLength, DefaultArrayPoolRentSize));

Internal\DefaultHybridCache.StampedeStateT.cs (1)

550int maxChars = Math.Max(key.Length, tags.MaxLength());

Internal\HybridCachePayload.cs (1)

283string[] newBuffer = ArrayPool<string>.Shared.Rent(Math.Max(4, pendingTagsCount * 2));

Internal\RecyclableArrayBufferWriter.cs (2)

168int growBy = Math.Max(sizeHint, currentLength); 172growBy = Math.Max(growBy, DefaultInitialBufferSize);

Internal\TagSet.cs (1)

211max = Math.Max(max, test.Length);

RedisCache.cs (1)

580return (long)Math.Min(

DependencyInjectionEventSource.cs (2)

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);

ServiceLookup\CallSiteFactory.cs (1)

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

DependencyContextJsonReader.cs (1)

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

Calculator.cs (1)

41double cpuUtilization = Math.Max(0.0, totalUsageTickDelta / totalSystemTicks * Hundred);

Linux\LinuxUtilizationProvider.cs (2)

229double percentage = Math.Min(One, (double)deltaCgroup / deltaHost); 262double memoryPercentage = Math.Min(One, (double)memoryUsed / _memoryLimit);

ResourceUtilization.cs (2)

68CpuUsedPercentage = Math.Min(Hundred, Throw.IfLessThan(cpuUsedPercentage / guaranteedCpuUnits, 0.0)); 71MemoryUsedPercentage = Math.Min(Hundred, (double)MemoryUsedInBytes / systemResources.GuaranteedMemoryInBytes * Hundred);

Windows\Disk\WindowsDiskIoTimePerfCounter.cs (1)

69float idleTimePercentage = Math.Min(counter.NextValue(), 100f);

Windows\WindowsContainerSnapshotProvider.cs (2)

204_memoryPercentage = Math.Min(_metricValueMultiplier, memoryUsage / _memoryLimit * _metricValueMultiplier); 239_cpuPercentage = Math.Min(_metricValueMultiplier, usageTickDelta / timeTickDelta * _metricValueMultiplier);

Windows\WindowsSnapshotProvider.cs (2)

143_memoryPercentage = Math.Min(_metricValueMultiplier, currentMemoryUsage / _totalMemory * _metricValueMultiplier); 176_cpuPercentage = Math.Min(_metricValueMultiplier, usageTickDelta / (double)timeTickDelta * _metricValueMultiplier);

CircularBufferTests.cs (1)

34var expectedBufferElements = elementsToAdd.Skip(Math.Max(0, elementsToAdd.Count - BufferSize)).ToList();

Linux\AcceptanceTest.cs (11)

180Assert.Equal(0.1, Math.Round(provider.Resources.GuaranteedCpuUnits, 1)); // hack to make hardcoded calculation in resource utilization main package work. 181Assert.Equal(0.2d, Math.Round(provider.Resources.MaximumCpuUnits, 1)); // read from cpuset.cpus 349var roundedCpuUsedPercentage = Math.Round(utilization.CpuUsedPercentage, 1); 354Assert.Equal(roundedCpuUsedPercentage, Math.Round(cpuRequestFromGauge * 100)); 356Assert.Equal(roundedCpuUsedPercentage, Math.Round(cpuFromGauge * 100)); 430var roundedCpuUsedPercentage = Math.Round(utilization.CpuUsedPercentage, 1); 432Assert.Equal(0, Math.Round(cpuLimitFromGauge * 100)); 433Assert.Equal(0, Math.Round(cpuRequestFromGauge * 100)); 510var roundedCpuUsedPercentage = Math.Round(utilization.CpuUsedPercentage, 1); 512Assert.Equal(42, Math.Round(cpuLimitFromGauge * 100)); 513Assert.Equal(83, Math.Round(cpuRequestFromGauge * 100));

Linux\LinuxUtilizationParserCgroupV2Tests.cs (2)

315var r = Math.Round(p.GetCgroupRequestCpuV2()); 534var r = Math.Round(p.GetCgroupRequestCpu());

Linux\Resources\FileNamesOnlyFileSystem.cs (1)

49var min = Math.Min(length, c.Length);

Linux\Resources\HardcodedValueFileSystem.cs (1)

80var min = Math.Min(toRead.Length, length);

ResourceUtilizationTests.cs (1)

23Assert.Equal(Math.Min(1.0, (double)MemoryUsed / MemoryTotal) * 100.0, utilization.MemoryUsedPercentage);

Windows\WindowsSnapshotProviderTests.cs (1)

162Assert.Equal(1 * multiplier, Math.Round(metricCollector.LastMeasurement.Value)); // Consuming 100% of the memory

PollingWildCardChangeToken.cs (1)

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

Logging\Internal\HttpRequestBodyReader.cs (1)

95var readLimit = Math.Min(readSizeLimit, (int)streamToReadFrom.Length);

Logging\AcceptanceTests.cs (1)

692var length = Math.Min(limit, responseString.Length);

Base32.cs (1)

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

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (2)

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

src\libraries\Common\src\System\Net\ArrayBuffer.cs (2)

161int newSize = Math.Max(desiredSize, (int)Math.Min(ArrayMaxLength, 2 * (uint)_bytes.Length));

LoggerMessageGenerator.Parser.cs (1)

921return ret == int.MinValue ? 0 : Math.Abs(ret); // Ensure the result is non-negative

Buffering\GlobalBuffer.cs (1)

137int currentBatchSize = Math.Min(MaxBatchSize, numItemsToEmit - offset);

Latency\Internal\LatencyConsoleExporter.cs (4)

65nameColumnWidth = Math.Max(nameColumnWidth, latencyData.Checkpoints[i].Name.Length); 81nameColumnWidth = Math.Max(nameColumnWidth, latencyData.Tags[i].Name.Length); 97nameColumnWidth = Math.Max(nameColumnWidth, latencyData.Measures[i].Name.Length); 132nameColumnWidth = Math.Max(nameColumnWidth, nameHeader.Length);

Emission\Emitter.Method.cs (1)

160return ret == int.MinValue ? 0 : Math.Abs(ret); // Ensure the result is non-negative

SyntaxExtensions.cs (1)

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

TypeSymbolExtensions.cs (1)

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

UseSiteAttributeProvider.cs (2)

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

src\Components\Shared\src\ArrayBuilder.cs (2)

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

Animations\Animation.cs (1)

217 var percent = Math.Min(start / Duration, 1);

Animations\Easing.cs (9)

31 public static readonly Easing SinOut = new(x => Math.Sin(x * Math.PI * 0.5f)); 36 public static readonly Easing SinIn = new(x => 1.0f - Math.Cos(x * Math.PI * 0.5f)); 41 public static readonly Easing SinInOut = new(x => -Math.Cos(Math.PI * x) / 2.0f + 0.5f); 51 public static readonly Easing CubicOut = new(x => Math.Pow(x - 1.0f, 3.0f) + 1.0f); 56 public static readonly Easing CubicInOut = new(x => x < 0.5f ? Math.Pow(x * 2.0f, 3.0f) / 2.0f : (Math.Pow((x - 1) * 2.0f, 3.0f) + 2.0f) / 2.0f);

Extensions\IndicatorViewExtensions.cs (1)

15 var minValue = Math.Min(indicatorView.MaximumVisible, indicatorView.Count);

Layouts\AbsoluteLayoutManager.cs (2)

49 measuredHeight = Math.Max(measuredHeight, bounds.Top + height); 50 measuredWidth = Math.Max(measuredWidth, bounds.Left + width);

Layouts\Flex.cs (2)

962 width = Math.Max(0, width - item.PaddingLeft + item.PaddingRight); 963 height = Math.Max(0, height - item.PaddingTop + item.PaddingBottom);

Layouts\FlexLayoutManager.cs (2)

63 measuredHeight = Math.Max(measuredHeight, frame.Bottom); 64 measuredWidth = Math.Max(measuredWidth, frame.Right);

Layouts\GridLayoutManager.cs (7)

638 starSize = Math.Max(starSize, dimension(_childrenToLayOut[cell.ViewIndex].DesiredSize)); 726 var cellRequiredHeight = Math.Min(_gridHeightConstraint, _childrenToLayOut[cell.ViewIndex].DesiredSize.Height); 750 var cellRequiredWidth = Math.Min(_gridWidthConstraint, _childrenToLayOut[cell.ViewIndex].DesiredSize.Width); 872 def.Size = Math.Min(maxSize, def.Size); 873 def.MinimumSize = Math.Min(maxSize, def.MinimumSize); 912 maxCurrentSize = Math.Max(maxCurrentSize, definitionSize); 913 maxCurrentStarSize = Math.Max(maxCurrentStarSize, definitionSize / definition.GridLength.Value);

Layouts\HorizontalStackLayoutManager.cs (1)

32 measuredHeight = Math.Max(measuredHeight, measure.Height);

Layouts\LayoutExtensions.cs (10)

46 consumedWidth = Math.Min(bounds.Width, view.MaximumWidth); 50 var frameWidth = Math.Max(0, consumedWidth - margin.HorizontalThickness); 60 consumedHeight = Math.Min(bounds.Height, view.MaximumHeight); 64 var frameHeight = Math.Max(0, consumedHeight - margin.VerticalThickness); 84 desiredWidth = IsExplicitSet(view.Width) ? desiredWidth : Math.Min(bounds.Width, view.MaximumWidth); 121 desiredHeight = IsExplicitSet(view.Height) ? desiredHeight : Math.Min(bounds.Height, view.MaximumHeight); 189 size.Width = Math.Max(bounds.Width, size.Width); 194 size.Height = Math.Max(bounds.Height, size.Height); 225 bounds.Width = Math.Max(bounds.Width, presentedContent.DesiredSize.Width + padding.HorizontalThickness); 226 bounds.Height = Math.Max(bounds.Height, presentedContent.DesiredSize.Height + padding.VerticalThickness);

Layouts\LayoutManager.cs (1)

33 return Math.Min(length, externalConstraint);

Layouts\VerticalStackLayoutManager.cs (1)

33 measuredWidth = Math.Max(measuredWidth, measure.Width);

Platform\ViewExtensions.cs (2)

38 internal static double ExtractAngleInRadians(this Matrix4x4 matrix) => Math.Atan2(matrix.M21, matrix.M11); 40 internal static double ExtractAngleInDegrees(this Matrix4x4 matrix) => ExtractAngleInRadians(matrix) * 180 / Math.PI;

Primitives\GridLength.cs (1)

69 return GridUnitType == other.GridUnitType && Math.Abs(Value - other.Value) < double.Epsilon;

Primitives\SwipeDirection.cs (3)

31 double rad = Math.Atan2(y1 - y2, x2 - x1) + Math.PI; 32 return (rad * 180 / Math.PI + 180) % 360;

VisualDiagnostics\AdornerModel.cs (17)

49 rc.Left = Math.Min(rect.Left - margin.Left, rect.Left); 50 rc.Width = Math.Abs(margin.Left); 60 rc.Left = Math.Min(rect.Right, rect.Right + margin.Right); 61 rc.Width = Math.Abs(margin.Right); 71 rc.Left = rect.Left - Math.Max(0, margin.Left); 72 rc.Right = rect.Right + Math.Max(0, margin.Right); 73 rc.Top = Math.Min(rect.Top - margin.Top, rect.Top); 74 rc.Height = Math.Abs(margin.Top); 82 rc.Left = rect.Left - Math.Max(0, margin.Left); 83 rc.Right = rect.Right + Math.Max(0, margin.Right); 84 rc.Top = Math.Min(rect.Bottom + margin.Bottom, rect.Bottom); 85 rc.Height = Math.Abs(margin.Bottom); 111 double floorPixels = (double)Math.Floor(pixels); 113 floorPixels : (double)Math.Ceiling(pixels); 161 return Math.Abs(value) < Tolerances.ZeroThreshold; 170 double eps = (Math.Abs(value1) + Math.Abs(value2) + 10.0) * Tolerances.Epsilon;

Animation.cs (2)

90 double val = Math.Max(0.0f, Math.Min(1.0f, (f - animation.StartDelay) / (animation.Duration)));

AnimationExtensions.cs (3)

292 double sign = velocity / Math.Abs(velocity); 293 velocity = Math.Abs(velocity); 300 velocity = Math.Max(0, velocity);

Brush\BrushTypeConverter.cs (1)

398 result = Math.Min(value / 100, 1f);

DisplayInfoExtensions.cs (1)

19 Math.Round(value);

GradientStop.cs (1)

47 return Color == dest.Color && global::System.Math.Abs(Offset - dest.Offset) < 0.00001;

ImageElement.cs (5)

66 height = Math.Min(desiredHeight, heightConstraint); 70 width = Math.Min(desiredWidth, widthConstraint); 82 width = Math.Min(desiredWidth, widthConstraint); 86 height = Math.Min(desiredHeight, heightConstraint); 94 width = Math.Min(desiredWidth, widthConstraint);

Internals\ImageParser.cs (2)

419 Delay = Math.Max(10, delay * 10); 429 return (short)(Math.Pow(2, (flags & 0x07) + 1));

Internals\ProfilePage.cs (1)

83 var percentage = (int)Math.Round(ticksMs / (double)profiledMs * 100);

Items\ItemsView.cs (2)

202 var maxWidth = Math.Min(scaled.Width, widthConstraint); 203 var maxHeight = Math.Min(scaled.Height, heightConstraint);

LegacyLayouts\AbsoluteLayout.cs (8)

103 bestFitSize.Width = Math.Max(bestFitSize.Width, desiredSize.Request.Width); 104 bestFitSize.Height = Math.Max(bestFitSize.Height, desiredSize.Request.Height); 105 minimum.Width = Math.Max(minimum.Width, desiredSize.Minimum.Width); 106 minimum.Height = Math.Max(minimum.Height, desiredSize.Minimum.Height); 204 width += sizeRequest.Value.Request.Width / Math.Max(0.25, bounds.Width); 223 height += sizeRequest.Value.Request.Height / Math.Max(0.25, bounds.Height); 285 result.X = Math.Round((region.Width - result.Width) * bounds.X); 294 result.Y = Math.Round((region.Height - result.Height) * bounds.Y);

LegacyLayouts\FlexLayout.cs (2)

464 widthConstraint = Math.Max(widthConstraint, item.Frame[0] + item.Frame[2] + item.MarginRight); 470 heightConstraint = Math.Max(heightConstraint, item.Frame[1] + item.Frame[3] + item.MarginBottom);

LegacyLayouts\Grid.cs (2)

388 private int RowCount() => Math.Max( 393 private int ColumnCount() => Math.Max(

LegacyLayouts\GridCalc.cs (33)

201 actualHeight = Math.Max(actualHeight, sizeRequest.Request.Height - assignedHeight - grid.RowSpacing * (GetRowSpan(child) - 1)); 202 minimumHeight = Math.Max(minimumHeight, sizeRequest.Minimum.Height - assignedHeight - grid.RowSpacing * (GetRowSpan(child) - 1)); 234 actualWidth = Math.Max(actualWidth, sizeRequest.Request.Width - assignedWidth - (GetColumnSpan(child) - 1) * grid.ColumnSpacing); 235 minimumWidth = Math.Max(minimumWidth, sizeRequest.Minimum.Width - assignedWidth - (GetColumnSpan(child) - 1) * grid.ColumnSpacing); 272 columnwWidthSum += Math.Max(0, c.ActualWidth); 284 rowHeightSum += Math.Max(0, r.ActualHeight); 317 double contractionNeeded = Math.Min(contractionSpace, Math.Max(currentSize.Width - targetWidth, 0)); 325 double availableSpace = col.ActualWidth - Math.Max(col.MinimumWidth, 0); 352 double contractionNeeded = Math.Min(contractionSpace, Math.Max(currentSize.Height - targetHeight, 0)); 394 starColumnWidth = Math.Min(column.ActualWidth, starColumnWidth); 411 double contractionNeeded = Math.Min(contractionSpace, Math.Max(request.Width - targetWidth, 0)); 457 starRowHeight = Math.Min(row.ActualHeight, starRowHeight); 473 double contractionNeeded = Math.Min(contractionSpace, Math.Max(request.Height - targetHeight, 0)); 500 lastRow = Math.Max(lastRow, GetRow(w) + GetRowSpan(w) - 1); 502 lastRow = Math.Max(lastRow, grid.RowDefinitions.Count - 1); 508 lastCol = Math.Max(lastCol, GetColumn(w) + GetColumnSpan(w) - 1); 510 lastCol = Math.Max(lastCol, grid.ColumnDefinitions.Count - 1); 605 starColWidth = Math.Max(starColWidth, GetUnassignedWidth(width, columnSpacing) / totalStarsWidth); 635 starRowHeight = Math.Max(starRowHeight, GetUnassignedHeight(height, rowSpacing) / totalStarsHeight); 677 actualWidth = Math.Max(actualWidth, sizeRequest.Request.Width - assignedWidth - columnSpacing); 678 minimumWidth = Math.Max(minimumWidth, sizeRequest.Minimum.Width - assignedWidth - columnSpacing); 697 starColRequestWidth = Math.Max(starColRequestWidth, col.ActualWidth / col.Width.Value); 698 starColMinWidth = Math.Max(starColMinWidth, col.MinimumWidth / col.Width.Value); 706 return Math.Max(widthConstraint / totalStarsWidth, starColMinWidth); 738 actualHeight = Math.Max(actualHeight, sizeRequest.Request.Height - assignedHeight - rowSpacing); 739 minimumHeight = Math.Max(minimumHeight, sizeRequest.Minimum.Height - assignedHeight - rowSpacing); 758 starRowRequestHeight = Math.Max(starRowRequestHeight, row.ActualHeight / row.Height.Value); 759 starRowMinHeight = Math.Max(starRowMinHeight, row.MinimumHeight / row.Height.Value); 767 return Math.Max(heightConstraint / totalStarsHeight, starRowMinHeight);

LegacyLayouts\Layout.cs (6)

249 double diff = Math.Max(0, region.Width - request.Request.Width); 266 double diff = Math.Max(0, region.Height - request.Request.Height); 460 double w = Math.Max(0, width - Padding.HorizontalThickness); 461 double h = Math.Max(0, height - Padding.VerticalThickness); 513 double diff = Math.Max(0, region.Width - request.Request.Width); 530 double diff = Math.Max(0, region.Height - request.Request.Height);

LegacyLayouts\RelativeLayout.cs (4)

225 boundsRectangle.Left = Math.Min(boundsRectangle.Left, bounds.Left); 226 boundsRectangle.Top = Math.Min(boundsRectangle.Top, bounds.Top); 227 boundsRectangle.Right = Math.Max(boundsRectangle.Right, bounds.Right); 228 boundsRectangle.Bottom = Math.Max(boundsRectangle.Bottom, bounds.Bottom);

LegacyLayouts\StackLayout.cs (8)

178 layout.CompressionSpace += Math.Max(0, request.Request.Height - request.Minimum.Height); 181 boundsWidth = Math.Max(boundsWidth, request.Request.Width); 184 minimumWidth = Math.Max(minimumWidth, request.Minimum.Width); 213 layout.CompressionSpace += Math.Max(0, request.Request.Width - request.Minimum.Width); 217 boundsHeight = Math.Max(boundsHeight, request.Request.Height); 219 minimumHeight = Math.Max(minimumHeight, request.Minimum.Height); 281 layout.Bounds.Height = Math.Max(layout.Bounds.Height, plot.Height); 353 layout.Bounds.Width = Math.Max(layout.Bounds.Width, plot.Width);

ListView\ListView.cs (2)

428 double width = Math.Min(scaled.Width, scaled.Height); 439 request = new Size(width, Math.Max(scaled.Width, scaled.Height));

MultiBinding.cs (1)

121 for (var i = 0; i < Math.Min(_bpProxies.Length, values.Length); i++)

NumericExtensions.cs (1)

13 if (Math.Abs(sizeA - sizeB) > Tolerance)

Page\Page.cs (4)

431 area.Width = Math.Max(0, area.Width); 432 area.Height = Math.Max(0, area.Height); 594 double w = Math.Max(0, Width - Padding.HorizontalThickness); 595 double h = Math.Max(0, Height - Padding.VerticalThickness);

ScrollView\ScrollView.cs (2)

320 contentRequest.Minimum = new Size(Math.Min(40, contentRequest.Minimum.Width), Math.Min(40, contentRequest.Minimum.Height));

Shapes\GeometryHelper.cs (20)

76 double x = elipGeoSrc.Center.X + elipGeoSrc.RadiusX * Math.Sin(i * 2 * Math.PI / max); 77 double y = elipGeoSrc.Center.Y - elipGeoSrc.RadiusY * Math.Cos(i * 2 * Math.PI / max); 290 double vectLength = Math.Sqrt(vect.X * vect.X + vect.Y * vect.Y); 301 double vectRotatedLength = Math.Sqrt(vectRotated.X * vectRotated.X + vectRotated.Y * vectRotated.Y); 308 double centerDistance = Math.Sqrt(Math.Abs((radiusY * radiusY) - (halfChord * halfChord))); 316 double angle1 = Math.Atan2(pt1.Y - center.Y, pt1.X - center.X); 317 double angle2 = Math.Atan2(pt2.Y - center.Y, pt2.X - center.X); 319 double sweep = Math.Abs(angle2 - angle1); 322 if (Math.IEEERemainder(sweep + 0.000005, Math.PI) < 0.000010) 328 bool isAcute = sweep < Math.PI; 335 angle1 += 2 * Math.PI; 337 angle2 += 2 * Math.PI; 344 int max = (int)(4 * (radiusX + radiusY) * Math.Abs(angle2 - angle1) / (2 * Math.PI) / tolerance); 349 double x = center.X + radiusY * Math.Cos(angle); 350 double y = center.Y + radiusY * Math.Sin(angle);

Shapes\Matrix.cs (24)

Shapes\PathFigureCollectionConverter.cs (2)

498 currentIndex = Math.Min(currentIndex + 8, pathLength); // "Infinity" has 8 characters 508 currentIndex = Math.Min(currentIndex + 3, pathLength); // "NaN" has 3 characters

Shapes\Rectangle.cs (1)

60 float cornerRadius = (float)Math.Max(RadiusX, RadiusY);

Shapes\RotateTransform.cs (3)

72 double radians = Math.PI * Angle / 180; 73 double sin = Math.Sin(radians); 74 double cos = Math.Cos(radians);

Shapes\RoundRectangle.cs (4)

92 float topLeftCornerRadius = (float)Math.Max(0, CornerRadius.TopLeft - strokeThickness); 93 float topRightCornerRadius = (float)Math.Max(0, CornerRadius.TopRight - strokeThickness); 94 float bottomLeftCornerRadius = (float)Math.Max(0, CornerRadius.BottomLeft - strokeThickness); 95 float bottomRightCornerRadius = (float)Math.Max(0, CornerRadius.BottomRight - strokeThickness);

Shapes\Shape.cs (2)

419 double minScale = Math.Min(scaleX, scaleY); 430 double maxScale = Math.Max(scaleX, scaleY);

Shapes\SkewTransform.cs (4)

86 double radiansX = Math.PI * AngleX / 180; 87 double radiansY = Math.PI * AngleY / 180; 88 double tanX = Math.Tan(radiansX); 89 double tanY = Math.Tan(radiansY);

Stepper\Stepper.cs (2)

38 return Math.Round(((double)value), stepper.digits).Clamp(stepper.Minimum, stepper.Maximum); 51 propertyChanged: (b, o, n) => { ((Stepper)b).digits = (int)(-Math.Log10((double)n) + 4).Clamp(1, 15); });

TableView\TableView.cs (2)

139 double width = Math.Min(scaled.Width, scaled.Height); 140 var request = new Size(width, Math.Max(scaled.Width, scaled.Height));

TemplatedItemsList.cs (2)

1000 maxindex = Math.Max(maxindex, e.NewStartingIndex + e.NewItems.Count); 1002 maxindex = Math.Max(maxindex, e.OldStartingIndex + e.OldItems.Count);

Tweener.cs (1)

124 Value = Math.Min(1.0f, ms / (double)Length);

VisualElement\VisualElement.cs (7)

1089 _batched = Math.Max(0, _batched - 1); 1169 widthConstraint = Math.Min(widthConstraint, widthRequest); 1171 heightConstraint = Math.Min(heightConstraint, heightRequest); 1200 minimum.Height = Math.Min(request.Height, minimum.Height); 1201 minimum.Width = Math.Min(request.Width, minimum.Width); 1242 widthConstraint = Math.Max(0, widthConstraint - margin.HorizontalThickness); 1243 heightConstraint = Math.Max(0, heightConstraint - margin.VerticalThickness);

BindingSourceGenerator.cs (1)

47 var code = BindingCodeWriter.GenerateBinding(binding, (uint)Math.Abs(location.GetHashCode()));

Types\Location.shared.cs (2)

67 if (Math.Abs(latitude) > 90) 73 if (Math.Abs(longitude) > 180)

UnitConverters\UnitConverters.shared.cs (10)

10 const double twoPi = 2.0 * Math.PI; 13 const double degreesToRadians = Math.PI / 180.0; 258 var dLat2 = Math.Sin(dLat / 2) * Math.Sin(dLat / 2); 259 var dLon2 = Math.Sin(dLon / 2) * Math.Sin(dLon / 2); 261 var a = dLat2 + dLon2 * Math.Cos(lat1) * Math.Cos(lat2); 262 var c = 2 * Math.Asin(Math.Sqrt(a));

AbstractCanvas.cs (2)

160 var halfHeight = Math.Abs(height / 2); 164 var halfWidth = Math.Abs(width / 2);

ArcFlattener.cs (4)

31 _diameter = Math.Max(width, height); 36 _sweep = Math.Abs(endAngle - startAngle); 67 var x2 = x + (Math.Cos(radians) * distance); 68 var y2 = y + (Math.Sin(radians) * distance);

Color.cs (11)

157 if (Math.Abs(alpha - Alpha) < GeometryUtil.Epsilon) 200 float v = Math.Max(Red, Green); 201 v = Math.Max(v, Blue); 202 float m = Math.Min(Red, Green); 203 m = Math.Min(m, Blue); 266 var range = (int)(Math.Floor(h * 6)) % 6; 267 var f = h * 6 - Math.Floor(h * 6); 526 float v = Math.Max(r, g); 527 v = Math.Max(v, b); 529 float m = Math.Min(r, g); 530 m = Math.Min(m, b);

GeometryUtil.cs (3)

35 return Math.PI * angle / 180; 45 return angle * (180 / Math.PI); 214 if (Math.Abs(vAdjustedValue - vRange) < Epsilon)

GradientPaint.cs (2)

127 var stopCount = Math.Min(colors.Length, offsets.Length); 196 if (Math.Abs(currentOffset - offset) < GeometryUtil.Epsilon)

Insets.cs (8)

61 return Math.Abs(_top - value) < GeometryUtil.Epsilon && Math.Abs(_left - value) < GeometryUtil.Epsilon && Math.Abs(_right - value) < GeometryUtil.Epsilon && 62 Math.Abs(_bottom - value) < GeometryUtil.Epsilon; 69 return Math.Abs(vCompareTo.Top - Top) < GeometryUtil.Epsilon && Math.Abs(vCompareTo.Left - Left) < GeometryUtil.Epsilon && Math.Abs(vCompareTo.Bottom - Bottom) < GeometryUtil.Epsilon && 70 Math.Abs(vCompareTo.Right - Right) < GeometryUtil.Epsilon;

InsetsF.cs (8)

61 return Math.Abs(_top - value) < GeometryUtil.Epsilon && Math.Abs(_left - value) < GeometryUtil.Epsilon && Math.Abs(_right - value) < GeometryUtil.Epsilon && 62 Math.Abs(_bottom - value) < GeometryUtil.Epsilon; 69 return Math.Abs(vCompareTo.Top - Top) < GeometryUtil.Epsilon && Math.Abs(vCompareTo.Left - Left) < GeometryUtil.Epsilon && Math.Abs(vCompareTo.Bottom - Bottom) < GeometryUtil.Epsilon && 70 Math.Abs(vCompareTo.Right - Right) < GeometryUtil.Epsilon;

Matrix3x2Extensions.cs (5)

53 var sx = matrix.M12 == 0 ? Math.Abs(matrix.M11) : new Vector2(matrix.M11, matrix.M12).Length(); 54 var sy = matrix.M21 == 0 ? Math.Abs(matrix.M22) : new Vector2(matrix.M21, matrix.M22).Length(); 72 var sx = matrix.M12 == 0 ? Math.Abs(matrix.M11) : new Vector2(matrix.M11, matrix.M12).Length(); 73 var sy = matrix.M21 == 0 ? Math.Abs(matrix.M22) : new Vector2(matrix.M21, matrix.M22).Length(); 150 count = Math.Min(dst.Length, count);

PathF.cs (9)

1145 xCornerRadius = Math.Min(xCornerRadius, rect.Width / 2); 1146 yCornerRadius = Math.Min(yCornerRadius, rect.Height / 2); 1148 float minX = Math.Min(rect.X, rect.X + rect.Width); 1149 float minY = Math.Min(rect.Y, rect.Y + rect.Height); 1150 float maxX = Math.Max(rect.X, rect.X + rect.Width); 1151 float maxY = Math.Max(rect.Y, rect.Y + rect.Height); 1316 if (Math.Abs(arcAngle - compareTo.GetArcAngle(i)) > GeometryUtil.Epsilon) 1373 if (Math.Abs(arcAngle - compareTo.GetArcAngle(i)) > epsilon) 1565 numberOfPoints = (int)(Math.Sqrt(rCurve / flatness)) + 3;

Point.cs (7)

62 return Math.Abs(compareTo.X - X) < epsilon && Math.Abs(compareTo.Y - Y) < epsilon; 80 return new Point((double)Math.Round(X), (double)Math.Round(Y)); 117 return (double)Math.Sqrt(Math.Pow(X - other.X, 2) + Math.Pow(Y - other.Y, 2));

PointF.cs (2)

56 return Math.Abs(compareTo.X - X) < epsilon && Math.Abs(compareTo.Y - Y) < epsilon;

Rect.cs (12)

107 return FromLTRB(Math.Min(r1.Left, r2.Left), Math.Min(r1.Top, r2.Top), Math.Max(r1.Right, r2.Right), Math.Max(r1.Bottom, r2.Bottom)); 117 double x = Math.Max(r1.X, r2.X); 118 double y = Math.Max(r1.Y, r2.Y); 119 double width = Math.Min(r1.Right, r2.Right) - x; 120 double height = Math.Min(r1.Bottom, r2.Bottom) - y; 209 return new Rect(Math.Round(X), Math.Round(Y), Math.Round(Width), Math.Round(Height));

RectF.cs (8)

108 return FromLTRB(Math.Min(r1.Left, r2.Left), Math.Min(r1.Top, r2.Top), Math.Max(r1.Right, r2.Right), Math.Max(r1.Bottom, r2.Bottom)); 118 float x = Math.Max(r1.X, r2.X); 119 float y = Math.Max(r1.Y, r2.Y); 120 float width = Math.Min(r1.Right, r2.Right) - x; 121 float height = Math.Min(r1.Bottom, r2.Bottom) - y;

ScalingCanvas.cs (2)

215 _scaleX *= Math.Abs(sx); 216 _scaleY *= Math.Abs(sy);

Text\AttributedTextExtensions.cs (5)

114 var paragraphLength = Math.Min(run.Length, length); 132 var paragraphStart = Math.Max(run.Start - start, 0); 133 var paragraphLength = Math.Min(run.Length, end - paragraphStart); 142 var paragraphStart = Math.Max(run.Start - start, 0); 143 var paragraphLength = Math.Min(run.Length, length - paragraphStart);

Text\AttributedTextRunExtensions.cs (10)

82 var length1 = Math.Min(first.Length, second.Length); 84 var length2 = Math.Max(first.Length, second.Length) - length1; 92 var length1 = Math.Min(first.Length, second.Length); 94 var length2 = Math.Max(first.Length, second.Length) - length1; 107 var length2 = Math.Max(first.Length, second.Length) - length1; 117 var length2 = Math.Max(first.Length, second.Length) - length1; 132 var length3 = Math.Max(first.Length, second.Length) - (length1 + length2); 145 var length3 = Math.Max(first.Length, second.Length) - (length1 + length2); 166 var start = Math.Max(run.Start, 0); 168 var length = Math.Min(run.Length, maxLength);

SkiaCanvas.cs (7)

291 float radius = (float)radialGradientPaint.Radius * Math.Max(rectangle.Height, rectangle.Width); 764 CurrentState.SetScale(Math.Abs(xFactor), Math.Abs(yFactor)); 823 var rx1 = Math.Min(x, x + width); 824 var ry1 = Math.Min(y, y + height); 825 var rx2 = Math.Max(x, x + width); 826 var ry2 = Math.Max(y, y + height);

SkiaTextLayout.cs (2)

111 var maxLines = Math.Floor(height / _lineHeight); 112 linesToDraw = (int)Math.Min(maxLines, lines.Count);

src\Graphics\src\Graphics\Platforms\Windows\PlatformCanvas.cs (7)

178 var absRotation = Math.Abs(rotation); 486 float radius = (float)radialGradientPaint.Radius * Math.Max(rectangle.Height, rectangle.Width); 566 var absRotation = Math.Abs(rotation); 853 _rect.X = Math.Min(x, x + width); 854 _rect.Y = Math.Min(y, y + height); 855 _rect.Width = Math.Abs(width); 856 _rect.Height = Math.Abs(height);

src\Graphics\src\Graphics\Platforms\Windows\PlatformCanvasState.cs (1)

445 public float ActualShadowBlur => ShadowBlur * Math.Abs(_scale);

src\Graphics\src\Graphics\Platforms\Windows\PlatformImage.cs (2)

140 canvas.DrawImage(this, dirtyRect.Left, dirtyRect.Top, Math.Abs(dirtyRect.Width), Math.Abs(dirtyRect.Height));

Primitives\Distance.cs (7)

63 var distance = Math.Sin((latitude2 - latitude1) / 2.0); 66 var intermediate = Math.Sin((longitude2 - longitude1) / 2.0); 69 distance = distance + Math.Cos(latitude1) * Math.Cos(latitude2) * intermediate; 70 distance = 2 * GeographyUtils.EarthRadiusKm * Math.Atan2(Math.Sqrt(distance), Math.Sqrt(1 - distance));

Primitives\GeographyUtils.cs (15)

12 public static double ToRadians(this double degrees) => degrees * Math.PI / 180.0; 14 public static double ToDegrees(this double radians) => radians / Math.PI * 180.0; 26 double latitude = Math.Asin(Math.Sin(centerLatitude) * Math.Cos(distance) + 27 Math.Cos(centerLatitude) * Math.Sin(distance) * Math.Cos(angleInRadians)); 29 Math.Atan2(Math.Sin(angleInRadians) * Math.Sin(distance) * Math.Cos(centerLatitude), 30 Math.Cos(distance) - Math.Sin(centerLatitude) * Math.Sin(latitude));

Primitives\MapSpan.cs (18)

8 const double EarthCircumferenceKm = GeographyUtils.EarthRadiusKm * 2 * Math.PI; 14 LatitudeDegrees = Math.Min(Math.Max(latitudeDegrees, MinimumRangeDegrees), 90.0); 15 LongitudeDegrees = Math.Min(Math.Max(longitudeDegrees, MinimumRangeDegrees), 180.0); 30 return new Distance(1000 * Math.Min(latKm, longKm) / 2); 36 north = Math.Min(Math.Max(north, 0), 90); 37 south = Math.Max(Math.Min(south, 0), -90); 38 double lat = Math.Max(Math.Min(Center.Latitude, north), south); 39 double maxDLat = Math.Min(north - lat, -south + lat) * 2; 40 return new MapSpan(new Location(lat, Center.Longitude), Math.Min(LatitudeDegrees, maxDLat), LongitudeDegrees); 80 double maxDLat = Math.Min(90 - Center.Latitude, 90 + Center.Latitude) * 2; 81 return new MapSpan(Center, Math.Min(LatitudeDegrees / zoomFactor, maxDLat), LongitudeDegrees / zoomFactor); 102 return EarthCircumferenceKm * Math.Cos(location.Latitude * Math.PI / 180.0);

SkiaSharpAppIconTools.cs (1)

156 var radius = Math.Min(canvasSize.Width, canvasSize.Height) / 2;

SkiaSharpTools.cs (3)

255 var nominalRatio = Math.Min( 266 (int)Math.Round(scaledWidth), 267 (int)Math.Round(scaledHeight));

AutoMLExperiment\IPerformanceMonitor.cs (2)

127_peakCpuUsage = Math.Max(cpuUsageInTotal, _peakCpuUsage ?? 0); 131_peakMemoryUsage = Math.Max(memoryUsage, _peakMemoryUsage ?? 0);

ColumnInference\TextFileSample.cs (5)

126averageLineLength = Math.Max(averageLineLength, 3); 131int chunkCount = (int)Math.Ceiling((BufferSizeMb * OversamplingRate - FirstChunkSizeMb) * (1 << 20) / usefulChunkSize); 132int maxChunkCount = (int)Math.Floor((double)(fileSize - firstChunk.Length) / chunkSize); 133chunkCount = Math.Min(chunkCount, maxChunkCount); 253int sniffLim = Math.Min(1000, buffer.Length);

Experiment\MetricsAgents\RankingMetricsAgent.cs (3)

42return metrics.NormalizedDiscountedCumulativeGains[Math.Min(metrics.NormalizedDiscountedCumulativeGains.Count, (int)_dcgTruncationLevel) - 1]; 44return metrics.DiscountedCumulativeGains[Math.Min(metrics.DiscountedCumulativeGains.Count, (int)_dcgTruncationLevel) - 1]; 73DcgTruncationLevel = Math.Max(10, 2 * (int)_dcgTruncationLevel)

Experiment\Runners\CrossValSummaryRunner.cs (1)

218var distFromAvg = Math.Abs(value - average);

Sweepers\Parameters.cs (22)

229? Math.Pow(1.0 * _args.Max / _args.Min, 1.0 / (_args.NumSteps - 1)) 231var logMax = Math.Log(_args.Max, logBase); 232var logMin = Math.Log(_args.Min, logBase); 233val = (long)(_args.Min * Math.Pow(logBase, normalizedValue * (logMax - logMin))); 258var logBase = _args.StepSize ?? Math.Pow(1.0 * _args.Max / _args.Min, 1.0 / (_args.NumSteps - 1)); 261var maxPlusEpsilon = _args.Max * Math.Sqrt(logBase); 313float logBase = (float)(_args.StepSize ?? Math.Pow(1.0 * _args.Max / _args.Min, 1.0 / (_args.NumSteps - 1))); 314return (float)((Math.Log(valueTyped.Value, logBase) - Math.Log(_args.Min, logBase)) / (Math.Log(_args.Max, logBase) - Math.Log(_args.Min, logBase))); 355? Math.Pow(1.0 * _args.Max / _args.Min, 1.0 / (_args.NumSteps - 1)) 357var logMax = Math.Log(_args.Max, logBase); 358var logMin = Math.Log(_args.Min, logBase); 359val = (float)(_args.Min * Math.Pow(logBase, normalizedValue * (logMax - logMin))); 376var logBase = _args.StepSize ?? Math.Pow(1.0 * _args.Max / _args.Min, 1.0 / (_args.NumSteps - 1)); 379var maxPlusEpsilon = _args.Max * Math.Sqrt(logBase); 431float logBase = (float)(_args.StepSize ?? Math.Pow(1.0 * _args.Max / _args.Min, 1.0 / (_args.NumSteps - 1))); 432return (float)((Math.Log(valueTyped.Value, logBase) - Math.Log(_args.Min, logBase)) / (Math.Log(_args.Max, logBase) - Math.Log(_args.Min, logBase)));

Sweepers\SmacSweeper.cs (2)

90return _randomSweeper.ProposeSweeps(Math.Min(numOfCandidates, _args.NumberInitialPopulation - numRuns), previousRuns); 157ParameterSet[] eiChallengers = GreedyPlusRandomSearch(bestKParamSets, forest, (int)Math.Ceiling(numOfCandidates / 2.0F), previousRuns);

Sweepers\SweeperProbabilityUtils.cs (9)

16return 1 / Math.Sqrt(2 * Math.PI) * Math.Exp(-Math.Pow(x, 2) / 2); 21return 0.5 * (1 + ProbabilityFunctions.Erf(x * 1 / Math.Sqrt(2))); 41rvs.Add(mu + sigma * Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2));

Tuner\Flow2.cs (3)

50_step = _stepSize * Math.Sqrt(_dim); 51_stepUpperBound = Math.Sqrt(_dim); 112_step = Math.Min(_step, _stepUpperBound);

Tuner\PipelineProposer.cs (3)

154_e2 = _pipelineSchemas.ToDictionary(id => id, id => loss + 0.05 * Math.Abs(loss)); 181var eci1 = Math.Max(_k1[schema], _k2[schema]); 183_eci[schema] = Math.Max(eci1, estimatorCostForBreakThrough);

Tuner\SmacTuner.cs (5)

241if (Math.Abs(eis[maxIndex] - currentBestEI) < _epsilon) 291var newFeatured = mu + sigma * Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2);

Utils\ArrayMath.cs (7)

42return xArray.Select(x => Math.Min(Math.Max(x, min), max)).ToArray(); 76return Math.Sqrt(s); 88return xArray.Select(x => Math.Log(x)).ToArray(); 136var rmse = Math.Sqrt(mean); 149var ape = diff.Select((x, i) => Math.Abs(x) / truth[i]); 162var diff = Enumerable.Range(0, truth.Length).Select(i => Math.Abs(truth[i] - pred[i])).ToArray();

Utils\RandomNumberGenerator.cs (4)

37double std = Math.Sqrt(-2.0 * Math.Log(u)) * Math.Sin(2.0 * Math.PI * v);

Utils\StringEditDistance.cs (2)

46rows[nextRow, j] = Math.Min(deletion, Math.Min(insertion, substitution));

SweeperTests.cs (6)

119double metric = -200 * (Math.Abs(100 - x1) + 120Math.Abs(300 - x2) + 121Math.Abs(500 - x3) + 122Math.Abs(700 - x4)); 169double metric = ((5 - Math.Abs(4 - foo)) * 200) + (1001 - Math.Abs(33 - bar)) + rand.Next(1, 20);

TunerTests.cs (7)

269bestMetric = Math.Max(bestMetric, metric); 324bestLoss = Math.Min(bestLoss, loss); 370bestMetric = Math.Min(bestMetric, metric); 433return Math.Log(Math.Exp(x) + Math.Exp(y) + Math.Exp(z));

CommandLine\CmdParser.cs (3)

866maxParamLen = Math.Max(maxParamLen, helpString.Syntax.Length); 875screenWidth = Math.Max(screenWidth, minimumScreenWidth); 915endIndex = helpStrings.Help.LastIndexOf(' ', endIndex - 1, Math.Min(endIndex - index, charsPerLine));

Utilities\BigArray.cs (2)

267Array.Resize(ref _entries[0], Math.Min(BlockSize, Math.Max(2 * curLastBlockSize, newLastBlockLength)));

Utilities\BinFinder.cs (2)

454return Math.Abs(_accum[i] - ideal) < Math.Abs(_accum[j] - ideal);

Utilities\DoubleParser.cs (1)

705Contracts.Assert(Math.Abs(exp) < int.MaxValue);

Utilities\MathUtils.cs (46)

32return Math.Sqrt(x).ToFloat(); 37return Math.Log(x).ToFloat(); 42return Math.Log(a, newBase).ToFloat(); 47return Math.Pow(x, y).ToFloat(); 115result = Math.Max(result, x); 129result = Math.Min(result, x); 230intermediate += Math.Exp(inputs[i] - max); 234return (float)(max + Math.Log(1.0 + intermediate)); 261return (float)(max + Math.Log(1.0 + Math.Exp(negDiff))); 288float absDiff = Math.Abs(a - b); 291float maxAbs = Math.Max(Math.Abs(a), Math.Abs(b)); 296private static readonly double _constantForLogGamma = 0.5 * Math.Log(2 * Math.PI); 312int toAdd = (int)Math.Floor(7 - x); 316res = -Math.Log(v2); 321res += _constantForLogGamma + (x + 0.5) * Math.Log(x) - x; 364_logFactorialCache.Add(_logFactorialCache[i - 1] + Math.Log(i)); 390return Math.Max(0, Math.Min(result, 1)); 421if (Math.Abs(ratio - 1.0) < tol) 431return Math.Exp(LogGamma(a) + LogGamma(b) - LogGamma(a + b)); 468return Math.Pow(x, a) * Math.Pow(1 - x, b) / (a * Beta(a, b)) * Lentz(adel, bdel); 524return Math.Tanh(x).ToFloat(); 532return Math.Exp(x).ToFloat(); 688maxOut = Math.Max(maxOut, src[i]); 753Double similarity = ab / (Math.Sqrt(a2 * b2) + epsilon); 755if (Math.Abs(similarity) > 1) 772? -prob * Math.Log(prob) - (1 - prob) * Math.Log(1 - prob) 773: -prob * Math.Log(prob, 2) - (1 - prob) * Math.Log(1 - prob, 2); 787? -probTrue * Math.Log(probPredicted) - (1 - probTrue) * Math.Log(1 - probPredicted) 788: -probTrue * Math.Log(probPredicted, 2) - (1 - probTrue) * Math.Log(1 - probPredicted, 2); 810soFar += Math.Exp(term - max); 813soFar = Math.Exp(max - term) * soFar + 1; 817return (float)Math.Log(soFar) + max; 826var res = Math.Sin(a); 827return Math.Abs(res) > 1 ? double.NaN : res; 836var res = Math.Cos(a); 837return Math.Abs(res) > 1 ? double.NaN : res;

Utilities\MatrixTransposeOps.cs (8)

40int iend = Math.Min(m - i, _block); 43int jend = Math.Min(n - j, _block); 99int iend = Math.Min(m - i, _block); 100int jend = Math.Min(n - j, _block); 151int iend = Math.Min(m - i, _block); 152int jend = Math.Min(n - j, _block); 204int iend = Math.Min(m - i, _block); 205int jend = Math.Min(n - j, _block);

Utilities\Stats.cs (31)

32int max = (int)Math.Ceiling(Math.Sqrt(rangeSize)); 45private static readonly double _vScale = 2 * Math.Sqrt(2 / Math.E); 63double y = Math.Abs(v) + 0.386595; 65} while (q > 0.27597 && (q > 0.27846 || v * v > -4 * u * u * Math.Log(u))); 82return SampleFromGamma(r, alpha + 1) * Math.Pow(r.NextDouble(), 1.0 / alpha); 85double c = 1 / Math.Sqrt(9 * d); 94v = Math.Pow(1.0 + c * x, 3); 99Math.Log(u) < 0.5 * xSqr + d * (1.0 - v + Math.Log(v))) 147double expLam = Math.Exp(-lambda); 159double sqrtLam = Math.Sqrt(lambda); 193logLam = Math.Log(lambda); 194double p = sqrtLam * Math.Exp(-lambda + k * logLam - logkFac); 224return (float)Math.Tan(Math.PI * (rand.NextSingle() - 0.5)); 271double pin = Math.Min(p, 1 - p); 291double s = Math.Pow(q, n); 315double spq = Math.Sqrt(npq); 340return (int)Math.Floor((a2 / (0.5 - Math.Abs(u)) + b) * u + c); 351u = Math.Sign(u) * 0.5 - u; 356double us = 0.5 - Math.Abs(u); 357double kd = Math.Floor((a2 / us + b) * u + c); 365m = (int)Math.Floor((n + 1) * p); 371int km = Math.Abs(k - m); 400v = Math.Log(v); 415h = (m + 0.5) * Math.Log((m + 1) / (r * nm)) + Fc(m) + Fc(n - m); 417double vval = h + (n + 1) * Math.Log((double)nm / (double)nk) + (k + 0.5) * Math.Log(nk * r / (double)(k + 1)) - Fc(k) - Fc(n - k);

Utilities\Stream.cs (2)

48(read = source.Read(buffer, 0, (int)Math.Min(buffer.Length, remaining))) != 0) 703int numElementsToReadThisChunk = Math.Min(maxChunkSizeInElements, destination.Length);

Utilities\SummaryStatistics.cs (20)

69public double SampleStdDev => Math.Sqrt(SampleVariance); 74public double StandardErrorMean => SampleStdDev / Math.Sqrt(RawCount); 218public double Skewness => Math.Sqrt(Count) * _m3 / Math.Pow(M2, 1.5); 241double y = b1 * Math.Sqrt((n + 1) * (n + 3) / (6 * (n - 2))); 243double w2 = -1.0 + Math.Sqrt(2.0 * (beta - 1.0)); 244double delta = 1.0 / Math.Sqrt(Math.Log(Math.Sqrt(w2))); 245double alpha = Math.Sqrt(2.0 / (w2 - 1.0)); 247double z1 = delta * Math.Log(yDivAlpha + Math.Sqrt(yDivAlpha * yDivAlpha + 1.0)); 274double x = (b2 - e) / Math.Sqrt(var); // Standardized b2. 277Math.Sqrt(n * (n - 2) * (n - 3) / (6 * (n + 3) * (n + 5))); 278double a = 6 + 8 * ibeta * (2 * ibeta + Math.Sqrt(1 + 4 * ibeta * ibeta)); 279double toCubeRoot = (1 - 2 / a) / (1 + x * Math.Sqrt(2 / (a - 4))); 280double z2 = (1 - 2 / (9 * a) - Math.Sign(toCubeRoot) * Math.Pow(Math.Abs(toCubeRoot), 1.0 / 3.0)) / 281Math.Sqrt(2 / (9 * a));

Utilities\SupervisedBinFinder.cs (2)

252Double logN = Math.Log(lim - min); 295entropy -= p * Math.Log(p);

Utilities\TextReaderStream.cs (3)

81_buff = new byte[Math.Max(_encoding.GetByteCount("\n"), _encoding.GetMaxByteCount(_charBlockSize))]; 140int charCount = Math.Min(_line.Length - _lineCur, _charBlockSize); 160int toCopy = Math.Min(count - readCount, _buffLim - _buffCur);

UnitTests\CoreBaseTestClass.cs (1)

66return FloatUtils.GetBits(x) == FloatUtils.GetBits(y) || Math.Abs(x - y) < DoubleEps;

UnitTests\TestLoss.cs (7)

49float almostOutput = Math.Max((float)output * (1 + _epsilon), (float)output + _epsilon); 76TestHelper(loss, 1, 3, Math.Exp(-3), Math.Exp(-3)); 77TestHelper(loss, 0, 3, Math.Exp(3), -Math.Exp(3)); 78TestHelper(loss, 0, -3, Math.Exp(-3), -Math.Exp(-3));

UnitTests\TestVBuffer.cs (11)

97float l1 = a.Items().Sum(iv => Math.Abs(iv.Value)); 101float infNorm = a.GetValues().Length == 0 ? 0 : a.Items().Max(iv => Math.Abs(iv.Value)); 830var l1Dist = a.Items(all: true).Zip(b.Items(all: true), (av, bv) => Math.Abs(av.Value - bv.Value)).Sum(); 870min = rgen.Next(Math.Min(max + 10, len + 100) - max - 2) + max + 2; 871max = rgen.Next(Math.Min(min + 10, len + 100) - min) + min; 899int expectedLength = Math.Max(1, a.Length - slotsDropped); 935var expectedVector = new VBuffer<float>(Math.Max(1, expectedLength), 1050if (FloatUtils.GetBits(i) == FloatUtils.GetBits(j) || Math.Abs(i - j) == 0) 1053float comp = Math.Abs(i - j) / (Math.Abs(i) + Math.Abs(j));

AvxIntrinsics.cs (2)

1556*pDst2Current = Math.Abs(dst1) > threshold ? (dst1 > 0 ? dst1 - threshold : dst1 + threshold) : 0; 1615pdst2[index] = Math.Abs(dst1) > threshold ? (dst1 > 0 ? dst1 - threshold : dst1 + threshold) : 0;

CpuMathUtils.netcoreapp.cs (5)

307sum += Math.Abs(source[i] - mean); 336float abs = Math.Abs(source[i]); 370float abs = Math.Abs(source[i] - mean); 545w[i] = Math.Abs(value) > threshold ? (value > 0 ? value - threshold : value + threshold) : 0; 588w[index] = Math.Abs(value) > threshold ? (value > 0 ? value - threshold : value + threshold) : 0;

EigenUtils.cs (12)

19var n = (int)Math.Sqrt(count); 38eigenvalues[i] = eigenvalues[i] <= 0 ? (float)(0.0) : (float)Math.Sqrt(eigenvalues[i]); 43x = Math.Abs(x); 44y = Math.Abs(y); 52return y * (float)Math.Sqrt(1 + t * t); 57return x * (float)Math.Sqrt(1 + t * t); 63float xx = Math.Abs(x); 134scale += Math.Abs(d[k]); 158g = CopySign((float)Math.Sqrt(h), (float)f); 358tst1 = Math.Abs(d[m]) + Math.Abs(d[m + 1]); 359tst2 = tst1 + Math.Abs(e[m]);

ProbabilityFunctions.cs (10)

32double t = 1.0 / (1.0 + p * Math.Abs(x)); 33double ev = ((((((((a5 * t) + a4) * t) + a3) * t) + a2) * t + a1) * t) * Math.Exp(-(x * x)); 53double t = 1.0 / (1.0 + p * Math.Abs(x)); 54double ev = 1.0 - ((((((((a5 * t) + a4) * t) + a3) * t) + a2) * t + a1) * t) * Math.Exp(-(x * x)); 83double cc = Math.Sqrt(Math.PI) / 2.0; 84double ccinc = Math.PI / 4.0; 126if (Math.Abs(q) <= 0.425) 140r = Math.Sqrt(-Math.Log(r));

SseIntrinsics.cs (2)

1235*pDst2Current = Math.Abs(dst1) > threshold ? (dst1 > 0 ? dst1 - threshold : dst1 + threshold) : 0; 1280pdst2[index] = Math.Abs(dst1) > threshold ? (dst1 > 0 ? dst1 - threshold : dst1 + threshold) : 0;

PerformanceTests.cs (1)

44double exponent = Math.Pow(2.0, rand.Next(-expRange + 1, expRange + 1));

UnitTests.cs (8)

711expected += Math.Abs(src[i]); 737expected += Math.Abs(src[i] - defaultScale); 761float abs = Math.Abs(src[i]); 790float abs = Math.Abs(src[i] - defaultScale); 944expected[i] = Math.Abs(value) > defaultScale ? (value > 0 ? value - defaultScale : value + defaultScale) : 0; 977expected[index] = Math.Abs(value) > defaultScale ? (value > 0 ? value - defaultScale : value + defaultScale) : 0; 1006return Math.Abs(a - b) < 1e-5f; 1019return Math.Abs(a - b) < 1e-3f;

Data\BufferBuilder.cs (8)

181Array.Resize(ref _values, Math.Max(Math.Min(_length, checked(_count * 2)), 8)); 183Array.Resize(ref _indices, Math.Max(Math.Min(_length, checked(_count * 2)), 8)); 209Array.Resize(ref _values, Math.Max(Math.Min(_length, checked(_count * 2)), 8)); 211Array.Resize(ref _indices, Math.Max(Math.Min(_length, checked(_count * 2)), 8));

Data\DataViewUtils.cs (2)

100int conc = Math.Max(2, Environment.ProcessorCount - 1); 103return Math.Min(num, 2 * conc);

DataLoadSave\Binary\BinaryLoader.cs (4)

783_threads = Math.Max(1, args.Threads ?? (Environment.ProcessorCount / 2)); 849_threads = Math.Max(1, Environment.ProcessorCount / 2); 857_threads = Math.Max(1, Environment.ProcessorCount / 2); 1171var poolSize = Math.Ceiling(_shuffleBlocks * _rowsPerBlock);

DataLoadSave\Binary\BinarySaver.cs (1)

771return Math.Max(1, rows); // Possible that even a single row exceeds the "limit".

DataLoadSave\Binary\Codecs.cs (2)

212int sublen = Math.Min(byteLength, _buffer.Length); 272int sublen = Math.Min(byteLength, _buffer.Length);

DataLoadSave\Binary\MemoryStreamPool.cs (1)

56return Math.Max(Utils.IbitHigh((uint)maxSize) - 15, 0);

DataLoadSave\Text\TextLoader.cs (1)

746inputSize = Math.Min(min, SrcLim - 1);

DataLoadSave\Text\TextLoaderCursor.cs (1)

79cthd = Math.Max(1, (int)cblkMax);

DataLoadSave\Text\TextLoaderParser.cs (3)

1135return Math.Max(src, inputSize); 1175int ichEnd = Math.Min(ichLim, ichCur + 9); 1447for (int srcCur = Math.Max(min, fields.Count); srcCur < lim; srcCur++)

DataView\AppendRowsDataView.cs (1)

445newEnd = _batchEnd + (int)Math.Ceiling((double)_rowsLeft[i] * BatchSize / _totalLeft);

DataView\CacheDataView.cs (1)

1105_currMax = Math.Min(_perm.Length - 1, _curr + _batchMask);

Deprecated\Instances\HeaderSchema.cs (3)

91int size = Math.Min(count, Utils.Size(names)); 302int size = Math.Min(Utils.Size(names), count); 380int size = Math.Min(names.Length, count);

Deprecated\Vector\VectorUtils.cs (2)

139var absValue = Math.Abs(value); 373(slot, val1, val2) => res += Math.Abs(val1 - val2));

Evaluators\AnomalyDetectionEvaluator.cs (2)

331var maxNumFalsePos = (int)Math.Ceiling(max); 407_maxNumFalsePos = (int)Math.Ceiling(max);

Evaluators\BinaryClassifierEvaluator.cs (4)

669logloss = -Math.Log(prob, 2); 672logloss = -Math.Log(1.0 - prob, 2); 1236return -Math.Log(prob, 2); 1237return -Math.Log(1.0 - prob, 2);

Evaluators\ClusteringEvaluator.cs (3)

266nmi += pxy * Math.Log(pxy / (px * py)); 269entropy += -px * Math.Log(px); 308maxi = Math.Max(maxi, num / denom);

Evaluators\EvaluatorUtils.cs (6)

1307vectorStdevMetrics[j] = Math.Sqrt(agg[iMetric + j].SumSq / numFolds - vectorMetrics[j] * vectorMetrics[j]); 1329dvBldr.AddColumn(agg[iMetric].Name, NumberDataViewType.Double, avg, Math.Sqrt(agg[iMetric].SumSq / numFolds - avg * avg)); 1401int numConfusionTableLabels = sample < 0 ? labelNames.Length : Math.Min(labelNames.Length, sample); 1553Math.Sqrt(sumSqMetrics[i] / numFolds - avg * avg))); 1610rowDigitLen = Math.Max(confusionMatrix.PredictedClassesIndicators.Count - 1, 0).ToString().Length; 1618int paddingLen = Math.Max(9, rowLabelLen);

Evaluators\MulticlassClassificationEvaluator.cs (9)

304entropy += _sumWeightsOfClass[i] * Math.Log(_sumWeightsOfClass[i] / _numInstances); 474float p = Math.Min(1, Math.Max(Epsilon, _scoresArr[intLabel])); 475logloss = -Math.Log(p); 480logloss = -Math.Log(Epsilon); 796float p = Math.Min(1, Math.Max(Epsilon, scoresArr[intLabel])); 797dst = -Math.Log(p); 801dst = -Math.Log(Epsilon);

Evaluators\MultiOutputRegressionEvaluator.cs (3)

220res[i] = Math.Sqrt(_l2Loss[i] / _sumWeights); 259Double currL1Loss = Math.Abs((Double)label[i] - score[i]); 268_sumEuclidean += Math.Sqrt(l2) * weight;

Evaluators\QuantileRegressionEvaluator.cs (4)

103res[i.Key] = Math.Sqrt(i.Value / SumWeights); 151var diff = Math.Abs((Double)label - scoreValues[i]); 163var diff = Math.Abs((Double)label - scoreValues[i]); 409l1Editor.Values[s.Key] = Math.Abs(lab - s.Value);

Evaluators\RankingEvaluator.cs (2)

972discountMap[i] = 1 / Math.Log(2 + i); 1005int maxTrunc = Math.Min(truncationLevel, queryLabels.Count);

Evaluators\RegressionEvaluator.cs (4)

97return SumWeights > 0 ? Math.Sqrt(TotalL2Loss / SumWeights) : 0; 119Double currL1Loss = Math.Abs((Double)label - score); 305dst = Math.Abs((Double)label - score); 315dst = Math.Abs((Double)label - score);

Prediction\Calibrator.cs (6)

1380_data = new DataItem[Math.Min(4, capacity)]; 1396Array.Sort(_data, 0, Math.Min(_itemsSeen, _capacity), comp); 1507offset = Math.Log((prior0 + 1) / (prior1 + 1)); 1590logp = Math.Log(p); 1592log1p = Math.Log(1 - p); 1780return (float)(1 / (1 + Math.Exp(a * output + b)));

Transforms\NormalizeColumnDbl.cs (21)

442get { return _m2.Select((m2, i) => Math.Sqrt(m2 / _cnz[i])).ToArray(); } 447get { return _m2.Select((m2, i) => Math.Sqrt(m2 / Math.Max(0, _cnz[i] - 1))).ToArray(); } 457get { return _m2.Select((m2, i) => m2 / Math.Max(0, _cnz[i] - 1)).ToArray(); } 511var val = _useLog ? (TFloat)Math.Log(origVal) : origVal; 732int cv = Math.Max(1, typeSrc.Size); 1006var val = UseLog ? (TFloat)Math.Log(input) : input; 1058int cv = Math.Max(1, typeSrc.Size); 1117var val = useLog ? (TFloat)Math.Log(values[i]) : values[i]; 1133var val = useLog ? (TFloat)Math.Log(values[ii]) : values[ii]; 1167_den = Math.Max(1, _binUpperBounds.Length - 1); 1242_den[i] = Math.Max(1, _binUpperBounds[i].Length - 1); 1261int cv = Math.Max(1, typeSrc.Size); 1436scale = 1 / Math.Max(Math.Abs(max), Math.Abs(min)); 1472scale = 1 / (TFloat)Math.Sqrt(meanSquaredError + mean * mean); 1489return (TFloat)(0.5 + 0.5 * Math.Sign(x) * Math.Sqrt(1 - Math.Exp(-x2 * (4 / Math.PI + ax2) / (1 + ax2))));

Transforms\NormalizeColumnSng.cs (21)

443get { return _m2.Select((m2, i) => Math.Sqrt(m2 / _cnz[i])).ToArray(); } 448get { return _m2.Select((m2, i) => Math.Sqrt(m2 / Math.Max(0, _cnz[i] - 1))).ToArray(); } 458get { return _m2.Select((m2, i) => m2 / Math.Max(0, _cnz[i] - 1)).ToArray(); } 513var val = _useLog ? (TFloat)Math.Log(origVal) : origVal; 889int cv = Math.Max(1, typeSrc.Size); 1166var val = UseLog ? (TFloat)Math.Log(input) : input; 1218int cv = Math.Max(1, typeSrc.Size); 1278var val = useLog ? (TFloat)Math.Log(values[i]) : values[i]; 1294var val = useLog ? (TFloat)Math.Log(values[ii]) : values[ii]; 1328_den = Math.Max(1, _binUpperBounds.Length - 1); 1403_den[i] = Math.Max(1, _binUpperBounds[i].Length - 1); 1422int cv = Math.Max(1, typeSrc.Size); 1599scale = 1 / Math.Max(Math.Abs(max), Math.Abs(min)); 1635scale = 1 / (TFloat)Math.Sqrt(meanSquaredError + mean * mean); 1652return (TFloat)(0.5 + 0.5 * Math.Sign(x) * Math.Sqrt(1 - Math.Exp(-x2 * (4 / Math.PI + ax2) / (1 + ax2))));

Transforms\RowShufflingTransformer.cs (1)

659int circularSwapIndex = (_rand.Next(Math.Min(_liveCount, _poolRows)) + _circularIndex) % _pipeIndices.Length;

Transforms\SkipTakeFilter.cs (2)

202return Math.Min(Math.Max(0, afterSkip), _take);

Transforms\SlotsDroppingTransformer.cs (4)

370slotsMax[iDst] = Math.Max(slotsMax[iDst], slotsMax[j]); 403slotsMax[i][iDst] = Math.Max(slotsMax[i][iDst], slotsMax[i][j]); 545type = new VectorDataViewType(vectorType.ItemType, Math.Max(dstLength, 1)); 841var type = new VectorDataViewType(vectorType.ItemType, Math.Max(dstLength, 1));

Utilities\SlotDropper.cs (3)

63int dstLength = srcLength - _lengthReduction[index] + Math.Max(SlotsMax[index] - srcLength + 1, 0); 133var lim = Math.Min(SlotsMin[i], src.Length); 153var newCount = Math.Min(srcValues.Length, newLength);

Utilities\TimerScope.cs (1)

45elapsedSeconds = Math.Round(elapsedSeconds);

Utils\LossFunctions.cs (20)

147return 1 / Math.Max(1, (float)0.25 + scaledFeaturesNormSquared); 161return maxNumThreads >= 2 && Math.Abs(fullUpdate) > Threshold ? fullUpdate / maxNumThreads : fullUpdate; 179return Math.Log(Math.Max(x, 1e-8)); 261var fullUpdate = truth * Math.Max(0, Math.Min(1, tmp)) - alpha; 262return maxNumThreads >= 2 && Math.Abs(fullUpdate) > Threshold ? fullUpdate / maxNumThreads : fullUpdate; 385var fullUpdate = truth * Math.Max(0, Math.Min(1, tmp)) - alpha; 386return maxNumThreads >= 2 && Math.Abs(fullUpdate) > Threshold ? fullUpdate / maxNumThreads : fullUpdate; 547return Math.Exp(output) - label * output; 552return (float)Math.Exp(output) - label; 633return output - label * Math.Log(output) + MathUtils.LogGamma(label); 638return output + label / output - Math.Sqrt(label); 640return Math.Pow(output, _index2) / _index2 - label * Math.Pow(output, _index1) / _index1 641- (Math.Pow(label, _index2) / _index2 - label * Math.Pow(label, _index1) / _index1); 651return (float)(Math.Pow(output, _index2) - label * Math.Pow(output, _index1));

Utils\SequencePool.cs (8)

82int ibit = Utils.IbitHigh((uint)Math.Max(_idLim, 31)); 90_hash = new uint[Math.Max(_idLim, 10)]; 91_next = new int[Math.Max(_idLim, 10)]; 134Contracts.Assert(0 <= _idLim && Math.Max(10, _idLim) <= Utils.Size(_start) - 1); 135Contracts.Assert(Math.Max(10, _idLim) <= Utils.Size(_hash)); 136Contracts.Assert(Math.Max(10, _idLim) <= Utils.Size(_next)); 138Contracts.Assert(0 <= _start[_idLim] && Math.Max(40, _start[_idLim]) <= Utils.Size(_bytes)); 260long newSize = Math.Max((long)_bytes.Length + _bytes.Length / 2, ibLim + cbMax);

Selector\DiversityMeasure\RegressionDisagreementDiversityMeasure.cs (1)

20return Math.Abs(valueX - valueY);

Trainer\EnsembleTrainerBase.cs (1)

134validationDataSetProportion = Math.Max(validationDataSetProportion, stackingTrainer.ValidationDatasetProportion);

Metrics\FairlearnMetricCatalog.cs (4)

246diffDict.Add("RSquared", Math.Abs((double)groupMetrics["RSquared"].Max() - (double)groupMetrics["RSquared"].Min())); 247diffDict.Add("RMS", Math.Abs((double)groupMetrics["RMS"].Max() - (double)groupMetrics["RMS"].Min())); 248diffDict.Add("MSE", Math.Abs((double)groupMetrics["MSE"].Max() - (double)groupMetrics["MSE"].Min())); 249diffDict.Add("MAE", Math.Abs((double)groupMetrics["MAE"].Max() - (double)groupMetrics["MAE"].Min()));

BinFile\BinFinder.cs (1)

161binUpperBounds = new double[Math.Max(1, numValues)];

Dataset\Dataset.cs (2)

578if (Math.Abs(fraction.Sum() - 1.0) > 1e-6) 754int maxTrunc = Math.Min(trunc, boundaries[q + 1] - boundaries[q]);

Dataset\FeatureFlock.cs (22)

213featureFirstUsePenalty : featureReusePenalty * Math.Log(featureUseCount[feature] + 1); 301double entropyGain = (totalCount * Math.Log(totalCount) - lteCount * Math.Log(lteCount) - gtCount * Math.Log(gtCount)); 325double erfcArg = Math.Sqrt((bestShiftedGain - gainShift) * (totalCount - 1) / (2 * leafSplitCandidates.VarianceTargets * totalCount)); 366: featureReusePenalty * Math.Log(featureUseCount[firstFlockFeature] + 1); 444double entropyGain = (totalCount * Math.Log(totalCount) - lteCount * Math.Log(lteCount) - 445gtCount * Math.Log(gtCount)); 484double erfcArg = Math.Sqrt((bestShiftedGain - gainShift) * (totalCount - 1) / (2 * leafSplitCandidates.VarianceTargets * totalCount)); 535double minDocs = Math.Max(learner.MinDocsForCategoricalSplit, 586: featureReusePenalty * Math.Log(featureUseCount[firstFlockFeature] + 1); 649double entropyGain = (totalCount * Math.Log(totalCount) - lteCount * Math.Log(lteCount) - 650gtCount * Math.Log(gtCount)); 696double erfcArg = Math.Sqrt((bestShiftedGain - gainShift) * (totalCount - 1) / (2 * leafSplitCandidates.VarianceTargets * totalCount)); 731double minDocs = Math.Max(learner.MinDocsForCategoricalSplit, 808: featureReusePenalty * Math.Log(featureUseCount[firstFlockFeature] + 1); 871double entropyGain = (totalCount * Math.Log(totalCount) - lteCount * Math.Log(lteCount) - 872gtCount * Math.Log(gtCount)); 918double erfcArg = Math.Sqrt((bestShiftedGain - gainShift) * (totalCount - 1) / (2 * leafSplitCandidates.VarianceTargets * totalCount));

Dataset\IntArray.cs (4)

325long sparseBits = (long)(Math.Max((int)classicBits, 8) + 8) * (long)(Length - zerocount + zoverflows); 342long bestCost = Math.Min(Math.Min(Math.Min(denseBits, sparseBits), rleBits), segBits);

FastTree.cs (5)

3154double normFactor = max == 0 ? 1.0 : (1.0 / Math.Sqrt(max)); 3160yield return new KeyValuePair<string, double>(name, Math.Sqrt(pair.Value) * normFactor); 3236var numFeatures = Math.Max(NumFeatures, MaxSplitFeatIdx + 1); 3247double normFactor = max == 0 ? 1.0 : (1.0 / Math.Sqrt(max)); 3251bldr.AddFeature(pair.Key, (float)(Math.Sqrt(pair.Value) * normFactor));

FastTreeClassification.cs (2)

389double response = label * _sigmoidParameter / (1.0 + Math.Exp(label * _sigmoidParameter * pScores[i])); 390double absResponse = Math.Abs(response);

FastTreeRanking.cs (5)

674_sigmoidTable[i] = 2.0 - 2.0 / (1.0 + Math.Exp(-2.0 * sigmoidParam * score)); 676_sigmoidTable[i] = 2.0 / (1.0 + Math.Exp(2.0 * sigmoidParam * score)); 897Math.Abs((pDiscount[i] - pDiscount[j])) * 915double normFactor = (10 * Math.Log(1 + lambdaSum)) / lambdaSum; 955_discount[d] = 1.0 / Math.Log(2.0 + d);

FastTreeTweedie.cs (9)

398_maxClamp = Math.Abs(options.MaximumTreeOutput); 421denom += w * Math.Exp(s); 431num += w * _labels[i] * Math.Exp(_index1 * s); 432denom += w * Math.Exp(_index2 * s); 436var step = shrinkage * (Math.Log(num) - Math.Log(denom)); 467Gradient[i] = Math.Exp(Scores[i]) - _labels[i]; 476Gradient[i] = Math.Exp(_index2 * Scores[i]) - _labels[i] * Math.Exp(_index1 * Scores[i]);

GamClassification.cs (2)

122var actions = new Action[(int)Math.Ceiling(1.0 * targets.Length / innerLoopSize)]; 127var toDoc = Math.Min(d + innerLoopSize, targets.Length);

GamTrainer.cs (3)

190_gainConfidenceInSquaredStandardDeviations = Math.Pow(ProbabilityFunctions.Probit(1 - (1 - GamTrainerOptions.GainConfidenceLevel) * 0.5), 2); 214_gainConfidenceInSquaredStandardDeviations = Math.Pow(ProbabilityFunctions.Probit(1 - (1 - GamTrainerOptions.GainConfidenceLevel) * 0.5), 2); 631return -4.0 * (Math.Abs(sumTargets) + sumWeights);

SumupPerformanceCommand.cs (7)

115double denom = Math.Log(1 - _param); 138int numZeros = (int)Math.Min(Math.Floor(Math.Log(r) / denom), remaining); 188double denom = Math.Log(1 - p); 207yield return Math.Floor(Math.Log(r) / denom);

Training\Applications\ObjectiveFunction.cs (2)

63var actions = new Action[(int)Math.Ceiling((double)Dataset.NumQueries / QueryThreadChunkSize)]; 74GetGradientChunk(start, start + Math.Min(QueryThreadChunkSize, Dataset.NumQueries - start), GradSamplingRate, sampleIndex, threadIndex);

Training\DcgCalculator.cs (8)

39DiscountMap[i] = 1.0 / Math.Log(2 + i); 122int maxTrunc = Math.Min(trunc, numDocuments); 145maxDcg += LabelMap[topLabel] / Math.Log(2.0 + t); 371var actions = new Action[(int)Math.Ceiling(1.0 * dataset.NumQueries / chunkSize)]; 379NdcgRangeWorkerChunkFromScores(dataset, labels, scores, result, start, Math.Min(dataset.NumQueries - start, chunkSize), threadIndex); 467Array.Sort(permutation, 0, Math.Min(count, _secondLevelcomparers[threadIndex].CompareFirstN), _secondLevelcomparers[threadIndex]); 510var actions = new Action[(int)Math.Ceiling(1.0 * dataset.NumQueries / chunkSize)]; 518OrderingRangeWorkerFromScores(dataset, scores, result, start, Math.Min(dataset.NumQueries - start, chunkSize), threadIndex);

Training\DocumentPartitioning.cs (2)

71var actions = new Action[(int)Math.Ceiling(1.0 * dataset.NumDocs / innerLoopSize)]; 76var toDoc = Math.Min(docStart + innerLoopSize, dataset.NumDocs);

Training\EnsembleCompression\LassoBasedEnsembleCompressor.cs (16)

66_numObservations = Math.Min(_trainSet.NumDocs, maxObservations); 110int selectedDocs = Math.Min(perLabelDocCount[curLabel], currentMax); 176int maxAllowedFeaturesAlongPath = (int)Math.Min(maxAllowedFeaturesPerModel * 1.2, _numFeatures); 192float factor = (float)(1.0 / Math.Sqrt(_numObservations)); 207featureStds[j] = Math.Sqrt(VectorUtils.GetDotProduct(_observations[j], _observations[j])); 223float targetStd = (float)Math.Sqrt(VectorUtils.GetDotProduct(_targets, _targets)); 239double alf = Math.Pow(Math.Max(Epsilon, flmin), 1.0 / (numberOfLambdas - 1)); 243int minimumNumberOfLambdas = Math.Min(MinNumberOFLambdas, numberOfLambdas); 263curLambda = Math.Max(curLambda, Math.Abs(feature2residualCorrelations[j])); 339maxDelta = Math.Max((delta >= 0 ? delta : -delta), maxDelta); 374maxDelta = Math.Max((delta >= 0 ? delta : -delta), maxDelta); 453fit.Lambdas[0] = Math.Exp(2 * Math.Log(fit.Lambdas[1]) - Math.Log(fit.Lambdas[2]));

Training\OptimizationAlgorithms\OptimizationAlgorithm.cs (1)

122Ensemble.RemoveAfter(Math.Max(bestIteration, 0));

Training\ScoreTracker.cs (2)

175var actions = new Action[(int)Math.Ceiling(1.0 * Dataset.NumDocs / innerLoopSize)]; 180var toDoc = Math.Min(d + innerLoopSize, Dataset.NumDocs);

Training\StepSearch.cs (2)

31_historicStepSize = Math.Max(1.0, _minStepSize); 34private static readonly double _phi = (1.0 + Math.Sqrt(5)) / 2;

Training\Test.cs (10)

137return Math.Sqrt(RawValue / Factor); 541var actions = new Action[(int)Math.Ceiling(1.0 * Dataset.NumDocs / chunkSize)]; 546var endDoc = Math.Min(documentStart + chunkSize - 1, Dataset.NumDocs - 1); 555l1Error += weight * Math.Abs(error); 619var actions = new Action[(int)Math.Ceiling(1.0 * binaryLabels.Length / chunkSize)]; 624var endDoc = Math.Min(documentStart + chunkSize - 1, binaryLabels.Length - 1); 659var actions = new Action[(int)Math.Ceiling(1.0 * Dataset.NumDocs / chunkSize)]; 664var endDoc = Math.Min(documentStart + chunkSize - 1, Dataset.NumDocs - 1); 680double loss = Math.Log(1.0 + Math.Exp(-1.0 * _sigmoidParameter * (label ? 1 : -1) * scores[i]));

Training\TreeLearners\LeastSquaresRegressionTreeLearner.cs (6)

622double absSumTargets = Math.Abs(sumTargets); 776double entropyGain = (totalCount * Math.Log(totalCount) - lteCount * Math.Log(lteCount) - gtCount * Math.Log(gtCount)); 801FeatureFirstUsePenalty : FeatureReusePenalty * Math.Log(FeatureUseCount[feature] + 1); 804double erfcArg = Math.Sqrt((bestShiftedGain - gainShift) * (totalCount - 1) / (2 * varianceTargets * totalCount));

Training\WinLossCalculator.cs (2)

53var actions = new Action[(int)Math.Ceiling(1.0 * dataset.NumQueries / chunkSize)]; 61WinLossRangeWorkerChunkFromScores(dataset, labels, scores, result, start, Math.Min(dataset.NumQueries - start, chunkSize), threadIndex));

TreeEnsemble\InternalRegressionTree.cs (7)

570Math.Abs(_splitGain[node] - tree._splitGain[node]) > 1e-6)) 1382var actions = new Action[(int)Math.Ceiling(1.0 * dataset.NumDocs / innerLoopSize)]; 1387var toDoc = Math.Min(d + innerLoopSize, dataset.NumDocs); 1407var actions = new Action[(int)Math.Ceiling(1.0 * dataset.NumDocs / innerLoopSize)]; 1412var toDoc = Math.Min(d + innerLoopSize, dataset.NumDocs); 1430var actions = new Action[(int)Math.Ceiling(1.0 * docIndices.Length / innerLoopSize)]; 1435var toDoc = Math.Min(d + innerLoopSize, docIndices.Length);

TreeEnsemble\InternalTreeEnsemble.cs (4)

296var actions = new Action[(int)Math.Ceiling(1.0 * dataset.NumDocs / innerLoopSize)]; 303var toDoc = Math.Min(d + innerLoopSize, dataset.NumDocs); 331double normalizingFactor = normalize && maxValue != 0 ? Math.Sqrt(maxValue) : 1.0; 337fmap.GetName(pair.Key), Math.Pow(pair.Value, power) / normalizingFactor));

Utils\LinqExtensions.cs (2)

270double total = values.Sum(value => Math.Exp(value - max)); 282r -= Math.Exp(value - max);

Utils\VectorUtils.cs (3)

16sum /= Math.Sqrt(sum); 135return Math.Sqrt(sum / vector.Length); 250return Math.Sqrt(sum);

Module\Attention.cs (1)

185attnWeights = attnWeights / Math.Sqrt(this._headDim);

Module\NewGELUActivation.cs (2)

23using var result3 = Math.Sqrt(2.0 / Math.PI) * result2;

Module\Phi2Attention.cs (1)

147attnWeights = attnWeights / Math.Sqrt(this._headDim);

Module\Phi3SuScaledRotaryEmbedding.cs (3)

72scalingFactor = Math.Sqrt(1 + Math.Log(scale) / Math.Log(this._originalMaxPositionEmbeddings));

VectorToImageTransform.cs (4)

410imageData[ix++] = (byte)Math.Round(blue * scale - offset); 411imageData[ix++] = (byte)Math.Round(green * scale - offset); 412imageData[ix++] = (byte)Math.Round(red * scale - offset); 413imageData[ix++] = (byte)(ex.Alpha ? Math.Round(alpha * scale - offset) : 0);

DataTransformation.cs (3)

44var petalMagnitude = Math.Sqrt(petalWidth * petalWidth + petalLength * petalLength); 45var sepalMagnitude = Math.Sqrt(sepalWidth * sepalWidth + sepalLength * sepalLength); 214Assert.InRange(row.Features[i], (uint)0, (uint)Math.Pow(2, 31));

SchemaDefinitionTests.cs (1)

85dst.Features[2 * i + 1] = (float)Math.Log(src.Features[i]);

KMeansModelParameters.cs (1)

172float distance = Math.Max(0,

KMeansPlusPlusTrainer.cs (12)

282maxThreads = Math.Min(maxThreads, argNumThreads.Value); 284return Math.Max(1, maxThreads); 401probabilityWeight = Math.Min(probabilityWeight, distance); 770maxInstancesToAccelerate = Math.Max(0, (accelMemBudgetMb * 1024 * 1024 - clusterBytes) / bytesPerInstance); 1190public double AverageScoreDelta => Math.Abs(PreviousAverageScore - AverageScore); 1476long maxInstancesToAccelerate = Math.Max(0, (accelMemBudgetMb * 1024 * 1024 - bytesPerCluster * k) / bytesPerInstance); 1534if (Math.Abs(a - b) < FloatingPointErrorThreshold) 1541if (Math.Abs(a) > Math.Abs(b)) 1542relativeError = Math.Abs((a - b) / a); 1544relativeError = Math.Abs((a - b) / b); 1635double key = Math.Log(rand.NextDouble()) / weight;

LightGbmMulticlassTrainer.cs (2)

285minLabel = Math.Min(minLabel, labelColumn); 286maxLabel = Math.Max(maxLabel, labelColumn);

LightGbmTrainerBase.cs (7)

952estimateNonZeroCnt = Math.Max(1, estimateNonZeroCnt); 1034batchSize = Math.Max(batchSize, catMetaData.NumCol); 1043batchRow = Math.Max(1, batchRow); 1084esimateBatchRow = Math.Max(1, esimateBatchRow); 1245ret = Math.Max(ret, 5); 1246ret = Math.Min(ret, 50); 1262ret = Math.Min(ret, numRow);

ComputeLRTrainingStdThroughHal.cs (2)

57stdErrorValues[0] = (float)Math.Sqrt(invHessian[0]); 89stdErrorValues[i] = (float)Math.Sqrt(stdErrorValues[i]);

OlsLinearRegression.cs (5)

149private static Double ProbClamp(Double p) => Math.Max(0, Math.Min(p, 1)); 526standardErrors[i] = Math.Sqrt(s2 * standardErrors[i]); 883Contracts.CheckDecode(Math.Sign(param) == Math.Sign(tvalue));

SymSgdClassificationTrainer.cs (2)

776int numPassesForThisBatch = Math.Min(numPassesForABatch, _options.NumberOfIterations - iter - numFinalPassesToTrainThoroughly); 778numPassesForThisBatch = Math.Max(1, numPassesForThisBatch);

VectorWhitening.cs (1)

416eigValues[i] = MathUtils.Sqrt(Math.Max(0, eigValues[i]) + ex.Epsilon);

PcaTrainer.cs (1)

218int oversampledRank = Math.Min(_rank + _oversampling, dimension);

PcaTransformer.cs (1)

310oversampledRank[iinfo] = Math.Min(transformInfos[iinfo].Rank + columns[iinfo].Oversampling, transformInfos[iinfo].Dimension);

CompareBaselines.cs (5)

273return Math.Abs(d1 - d2) / Math.Max(1, Math.Max(Math.Abs(d1), Math.Abs(d2)));

TestPredictors.cs (1)

741Assert.Equal(prob, 1 / (1 + Math.Exp(-score)), 0.000001);

ResultProcessor.cs (1)

982foldIdx += (int)(foldIdxExtra * Math.Pow(1000, j));

Dynamic\Trainers\BinaryClassification\Gam.cs (1)

174private static double Sigmoid(double x) => 1.0 / (1.0 + Math.Exp(-1 * x));

Dynamic\Trainers\BinaryClassification\GamWithOptions.cs (1)

181private static double Sigmoid(double x) => 1.0 / (1.0 + Math.Exp(-1 * x));

Dynamic\Trainers\BinaryClassification\PermutationFeatureImportance.cs (2)

53feature => Math.Abs(feature.AreaUnderRocCurve.Mean)) 118private static double Sigmoid(double x) => 1.0 / (1.0 + Math.Exp(-1 * x));

Dynamic\Trainers\BinaryClassification\PermutationFeatureImportanceLoadFromDisk.cs (2)

52feature => Math.Abs(feature.AreaUnderRocCurve.Mean)) 104private static double Sigmoid(double x) => 1.0 / (1.0 + Math.Exp(-1 * x));

Dynamic\Trainers\MulticlassClassification\PermutationFeatureImportance.cs (1)

55.OrderByDescending(feature => Math.Abs(feature.MicroAccuracy.Mean))

Dynamic\Trainers\MulticlassClassification\PermutationFeatureImportanceLoadFromDisk.cs (1)

63.OrderByDescending(feature => Math.Abs(feature.MicroAccuracy.Mean))

Dynamic\Trainers\Ranking\PermutationFeatureImportance.cs (1)

56.OrderByDescending(feature => Math.Abs(

Dynamic\Trainers\Ranking\PermutationFeatureImportanceLoadFromDisk.cs (1)

63.OrderByDescending(feature => Math.Abs(

Dynamic\Trainers\Regression\GamAdvanced.cs (1)

172private static double Sigmoid(double x) => 1.0 / (1.0 + Math.Exp(-1 * x));

Dynamic\Trainers\Regression\GamWithOptionsAdvanced.cs (1)

180private static double Sigmoid(double x) => 1.0 / (1.0 + Math.Exp(-1 * x));

Dynamic\Trainers\Regression\PermutationFeatureImportance.cs (1)

58.OrderByDescending(feature => Math.Abs(

Dynamic\Trainers\Regression\PermutationFeatureImportanceLoadFromDisk.cs (1)

65.OrderByDescending(feature => Math.Abs(

Dynamic\Transforms\CalculateFeatureContributionCalibrated.cs (1)

143private static double Sigmoid(double x) => 1.0 / (1.0 + Math.Exp(-1 * x));

Dynamic\Transforms\TimeSeries\DetectSeasonality.cs (2)

18var seasonalData = Enumerable.Range(0, 100).Select(x => new TimeSeriesData(Math.Sin(2 * Math.PI + x)));

Option\ChoiceOption.cs (1)

85var idx = Convert.ToInt32(Math.Floor(value));

Option\UniformNumericOption.cs (5)

63var logMax = Math.Log(Max); 64var logMin = Math.Log(Min); 65var logX = Math.Log(x); 84var order = Math.Pow(Max / Min, value); 180var intValue = Convert.ToInt32(Math.Floor(param.AsType<double>()));

SearchSpaceTest.cs (1)

372writer.WriteNumberValue(Math.Round(Convert.ToDecimal(value), 6));

UniformNumericOptionTests.cs (5)

65var sampleInputs = Enumerable.Range(0, 10).Select(i => Parameter.FromInt(Convert.ToInt32(Math.Pow(2, i)))); 83.All((x) => Math.Abs(x.Item1 - x.Item2) < 1e-5) 95sampleOutputs.Select((x, i) => (x.AsType<double>(), Math.Pow(2, i))) 96.All((x) => Math.Abs(x.Item1 - x.Item2) < 1e-5) 116var sampleInputs = Enumerable.Range(0, 10).Select(i => Parameter.FromDouble(Math.Pow(2, i)));

LdSvm\LdSvmModelParameters.cs (2)

254score += Math.Tanh(_sigma * (VectorUtils.DotProduct(in _thetaPrime[current], in src) + _biasThetaPrime[current])) * 259score += Math.Tanh(_sigma * (VectorUtils.DotProduct(in _thetaPrime[current], in src) + _biasThetaPrime[current])) *

LdSvm\LdSvmTrainer.cs (14)

212tanhThetaTx[i] = (float)Math.Tanh(gamma * (VectorUtils.DotProduct(in feat, in theta[i]) + biasTheta[i])); 241tempSum += Math.Abs(VectorUtils.DotProduct(in s, in theta[thetaIdx]) + biasTheta[thetaIdx]); 246gamma *= (float)Math.Pow(2.0, iter / (_options.NumberOfIterations / 10.0)); 284int sampleSize = Math.Max(1, (int)Math.Sqrt(data.Length)); 292float etaTW = (float)1.0 / (_options.LambdaW * (float)Math.Sqrt(iter + 1)); 293float etaTTheta = (float)1.0 / (_options.LambdaTheta * (float)Math.Sqrt(iter + 1)); 294float etaTThetaPrime = (float)1.0 / (_options.LambdaThetaprime * (float)Math.Sqrt(iter + 1)); 324var tanhDist = (float)Math.Tanh(gamma * (VectorUtils.DotProduct(in features, in theta[i]) + biasTheta[i])); 331localWt[l] = (float)Math.Tanh(_options.Sigma * (VectorUtils.DotProduct(in features, in thetaPrime[l]) + biasThetaPrime[l])); 531var sampleSize = Math.Max(1, (int)Math.Sqrt(Length)); 620var sampleSize = Math.Max(1, (int)Math.Sqrt(Length));

Optimizer\DifferentiableFunction.cs (11)

198int numIters = Math.Min((int)x.Length, 10); 199int maxDirCount = Math.Min((int)x.Length / 2, 100); 203int dirCount = Math.Min(n * 10, maxDirCount); 228float normDiff = Math.Abs(1 - numDeriv / dirDeriv); 233maxNormDiff = Math.Max(maxNormDiff, normDiff); 275float normDiff = Math.Abs(1 - numDeriv / dirDeriv); 314float normDiff = Math.Abs(1 - numDeriv / dirDeriv); 348float normDiff = Math.Abs(1 - numDeriv / dirDeriv); 360return (float)(Math.Sqrt(-2 * Math.Log(a)) * MathUtils.Cos(2 * Math.PI * b));

Optimizer\L1Optimizer.cs (3)

107(ind, value) => { if (ind >= _biasCount) res += Math.Abs(value); }); 109VBufferUtils.ForEachDefined(in input, (ind, value) => res += Math.Abs(value)); 157return -Math.Min(gradVal + _l1weight, 0);

Optimizer\LearningRateScheduler.cs (6)

195decayPower = Staircase ? (float)Math.Floor(decayPower) : decayPower; 196float decayedLearningRate = LearningRate * (float)Math.Pow(DecayRate, decayPower); 253float calculatedStep = (float)decaySteps * (float)Math.Ceiling((double)globalStep / (double)decaySteps); 254decayedLearningRate = (LearningRate - EndLearningRate) * ((float)Math.Pow((1 - (float)globalStep / calculatedStep), Power)) + EndLearningRate; 258float calculatedStep = Math.Min(globalStep, decaySteps); 259decayedLearningRate = (LearningRate - EndLearningRate) * ((float)Math.Pow((1 - calculatedStep / (float)decaySteps), Power)) + EndLearningRate;

Optimizer\LineSearch.cs (6)

102float t2 = Math.Sign(b.Step - a.Step) * MathUtils.Sqrt(t1 * t1 - a.Deriv * b.Deriv); 163return Math.Min(_step, MaxStep); 333return Math.Min(_step, MaxStep); 457double e = Math.Exp(x); 459return (float)(Math.Log(1 + 1.0 / e) + Math.Log(1 + e) - 0.5 * x);

Optimizer\OptimizationMonitor.cs (4)

252float val = avgImprovement / Math.Abs(value); 326_bestBoundOnMin = Math.Max(_bestBoundOnMin, newBoundOnMin); 327float val = (value - _bestBoundOnMin) / Math.Abs(value); 381float val = norm / Math.Abs(state.Value);

Optimizer\Optimizer.cs (5)

312return -Math.Min(gradVal, 0); 434else if (Math.Abs(curr.D) <= -c2) 514else if (Math.Abs(curr.D) <= -c2) 543double t2 = Math.Sign(p1.A - p0.A) * Math.Sqrt(t1 * t1 - p0.D * p1.D);

Optimizer\SgdOptimizer.cs (1)

345float beta = Math.Max(0, betaPR);

Standard\LinearPredictorUtils.cs (4)

46if (Math.Abs(value - 0) >= Epsilon) 113if (Math.Abs(value - 0) >= Epsilon) 211.Where(weight => Math.Abs(weight.Value) >= Epsilon) 212.OrderByDescending(kv => Math.Abs(kv.Value));

Standard\LogisticRegression\LbfgsPredictorBase.cs (1)

655int numNew = Math.Max(1, (int)NumGoodRows / 100);

Standard\LogisticRegression\LogisticRegression.cs (5)

200float label01 = Math.Min(1, Math.Max(label, 0)); 250VBufferUtils.ForEachDefined(in CurrentWeights, (ind, value) => { if (ind >= BiasCount) regLoss += Math.Abs(value); }); 254ch.Info("Residual Deviance: \t{0} (on {1} degrees of freedom)", deviance, Math.Max(NumGoodRows - numParams, 0)); 351var variance = weight / (2 + 2 * Math.Cosh(score));

Standard\LogisticRegression\MulticlassLogisticRegression.cs (3)

336VBufferUtils.ForEachDefined(in CurrentWeights, (ind, value) => { if (ind >= BiasCount) regLoss += Math.Abs(value); }); 351nullDeviance -= (float)(2 * _prior[iLabel] * Math.Log(_prior[iLabel] / WeightSum)); 850var orderedWeights = Weights[classNumber].Items().OrderByDescending(kv => Math.Abs(kv.Value));

Standard\ModelStatistics.cs (3)

346var pValue = 1.0f - (float)ProbabilityFunctions.Erf(Math.Abs(zScore / sqrt2)); 381pValueEditor.Values[i - 1] = 1 - (float)ProbabilityFunctions.Erf(Math.Abs(zScoreEditor.Values[i - 1] / sqrt2)); 424var pValue = 1 - (float)ProbabilityFunctions.Erf(Math.Abs(zScore / sqrt2));

Standard\MulticlassClassification\MulticlassNaiveBayesTrainer.cs (7)

399Math.Log(1 + ((double)labelOccuranceCount - featureHistogram[iLabel][iFeature])) - 400Math.Log(labelOccuranceCount + labelCount); 592logProb += Math.Log(featureCount + 1) - Math.Log(labelOccurrenceCount + _labelCount); 593absentFeatureLogProb += Math.Log(absentFeatureCount + 1) - Math.Log(labelOccurrenceCount + _labelCount); 608double logProb = Math.Log(labelOccurrenceCount / _totalTrainingCount);

Standard\MulticlassClassification\OneVersusAllTrainer.cs (1)

901score[i] = Math.Exp(scores[i]);

Standard\MulticlassClassification\PairwiseCouplingTrainer.cs (1)

449return pii / Math.Max(pii, sum - (_numClasses - 2) * pii);

Standard\Online\AveragedLinear.cs (1)

255PendingMultipliers += Math.Abs(biasUpdate);

Standard\Online\LinearSvm.cs (1)

243float normalizer = 1 / (MathUtils.Sqrt(_lambda) * VectorUtils.Norm(Weights) * Math.Abs(WeightsScale));

Standard\Online\OnlineLinear.cs (3)

195float absWeightsScale = Math.Abs(WeightsScale); 298float maxNorm = Math.Max(VectorUtils.MaxNorm(in state.Weights), Math.Abs(state.Bias));

Standard\SdcaBinary.cs (11)

141=> Math.Min(8, Math.Max(1, Environment.ProcessorCount / 2)); 690int maxIterations = (int)Math.Max(1, 500000 / count) * 3; 692maxIterations = Math.Max(2, Math.Max(1, maxIterations / numThreads) * numThreads); 706long expectedIterations = Math.Max(2, maxIterations / 2 / numThreads) * numThreads; 709float l2 = Math.Max(1e-06f, 20f / (expectedIterations * rowCount)); 873biasReg[0] = Math.Abs(l1IntermediateBias[0]) - l1Threshold > 0.0 874? l1IntermediateBias[0] - Math.Sign(l1IntermediateBias[0]) * l1Threshold 996Double l1Regularizer = l1Threshold * l2Const * (VectorUtils.L1Norm(in weights[0]) + Math.Abs(biasReg[0])); 2064Double loss = Math.Log(2); // for log loss, this is exact; for Hinge, it's a reasonable estimate

Standard\SdcaMulticlass.cs (5)

291biasReg[iClass] = Math.Abs(l1IntermediateBias[iClass]) - l1Threshold > 0.0 292? l1IntermediateBias[iClass] - Math.Sign(l1IntermediateBias[iClass]) * l1Threshold 321biasReg[label] = Math.Abs(intermediateBias) - l1Threshold > 0.0 322? intermediateBias - Math.Sign(intermediateBias) * l1Threshold 421weightsL1Norm += VectorUtils.L1Norm(in weights[iClass]) + Math.Abs(biasReg[iClass]);

Standard\SdcaRegression.cs (2)

171=> Math.Min(2, Math.Max(1, Environment.ProcessorCount / 2));

Standard\StochasticTrainerBase.cs (2)

48=> Math.Min(8, Math.Max(1, Environment.ProcessorCount / 2));

Algorithms\KdoSweeper.cs (12)

113var numSweeps = Math.Min(numOfCandidates, _args.NumberInitialPopulation - prevRuns.Length); 171double rVar = Math.Pow(VectorUtils.GetStandardDeviation(randomVals), 2) + 1e-10; 250double bandwidthScale = Math.Max(_args.MinimumMutationSpread, correctedVal); 265double eps = Math.Min(Math.Max(child[index], epsCutoff), 1 - epsCutoff); 300double p2 = Math.Pow((4.0 / (d + 2)), p1); 306bandwidthMatrix[i][i] = p2 * stddevs[i] * Math.Pow(n, -p1); 337weights[i] = _args.Simple ? Math.Pow(weights[i], Math.Min(Math.Sqrt(n), 100)) : Math.Pow(weights[i], _args.WeightRescalingPower * currentMaxPerf); 471a[i][j] = i + j == d - 1 ? Math.Sqrt(diagonalCovariance[i][i]) : 0;

Algorithms\NelderMead.cs (4)

127int numSweeps = Math.Min(maxSweeps, _dim + 1 - _simplexVertices.Count); 149numSweeps = Math.Min(maxSweeps, _dim + 1 - _simplexVertices.Count); 401int numPoints = Math.Min(maxSweeps, _dim); 419int numPoints = Math.Min(maxSweeps, _pendingSweepsNotSubmitted.Count);

Algorithms\SmacSweeper.cs (2)

95return _randomSweeper.ProposeSweeps(Math.Min(numOfCandidates, _args.NumberInitialPopulation - numRuns), previousRuns); 168ParameterSet[] eiChallengers = GreedyPlusRandomSearch(bestKParamSets, forest, (int)Math.Ceiling(numOfCandidates / 2.0F), previousRuns);

Algorithms\SweeperProbabilityUtils.cs (17)

32variance = Math.Max(variance, minVariance); 33return 1 / Math.Sqrt(2 * Math.PI * variance) * Math.Exp(-Math.Pow(x - mean, 2) / (2 * variance)); 39double ztrans = centered / (Math.Sqrt(variance) * Math.Sqrt(2)); 46return 1 / Math.Sqrt(2 * Math.PI) * Math.Exp(-Math.Pow(x, 2) / 2); 51return 0.5 * (1 + ProbabilityFunctions.Erf(x * 1 / Math.Sqrt(2))); 71rvs.Add(mu + sigma * Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2)); 88if (Math.Abs(1.0 - total) > 0.0001)

AsyncSweeper.cs (1)

250PrepareNextBatch(_results.GetRange(0, Math.Max(0, _numGenerated - _relaxation)));

Parameters.cs (22)

SynthConfigRunner.cs (3)

90total += Math.Pow(val, 2) - 10 * Math.Cos(2 * Math.PI * val);

TestSweeper.cs (1)

661Assert.Equal(Math.Min(args.NumberInitialPopulation, maxInitSweeps), sweeps.Length);

TensorflowTransform.cs (1)

614var d = numOfUnkDim > 0 ? Math.Pow(typeValueCount / valCount, 1.0 / numOfUnkDim) : 0;

BaseTestBaseline.cs (8)

636double allowedVariance = Math.Pow(10, -digitsOfPrecision); 639delta = Math.Round(delta, digitsOfPrecision); 654delta2 = Math.Round(expected - actual, digitsOfPrecision); 680double absValue = Math.Abs(value); 681double integralDigitCount = Math.Floor(Math.Log10(absValue) + 1); 683double scale = Math.Pow(10, integralDigitCount); 684return scale * Math.Round(value / scale, digitsOfPrecision);

DataPipe\TestDataPipeBase.cs (2)

989return FloatUtils.GetBits(x) == FloatUtils.GetBits(y) || Math.Abs(x - y) < DoubleEps; 997return FloatUtils.GetBits(x) == FloatUtils.GetBits(y) || Math.Abs(x - y) < SingleEps;

PermutationFeatureImportanceTests.cs (1)

254Assert.Equal(pfi[0].RootMeanSquaredError.StandardError, pfi[0].RootMeanSquaredError.StandardDeviation / Math.Sqrt(pfi[0].RootMeanSquaredError.Count));

Scenarios\Api\TestApi.cs (1)

244Assert.True(Math.Abs(retrievedFloat - valueFloat) < .000001);

Scenarios\ClusteringTests.cs (4)

40clusters[i] = new ClusteringData { Points = new float[2] { (float)Math.Cos(Math.PI * i * 2 / k), (float)Math.Sin(Math.PI * i * 2 / k) } };

TrainerEstimators\MatrixFactorizationTests.cs (2)

132double windowsAndMacTolerance = Math.Pow(10, -7); 133double linuxTolerance = Math.Pow(10, -5);

TrainerEstimators\TreeEstimators.cs (4)

674sum += Math.Exp((float)nativeResult1[j + i * _classNumber]); 678double prob = Math.Exp(nativeResult1[j + i * _classNumber]); 703sum += Math.Exp((float)nativeResult1[j + i * _classNumber]); 707double prob = Math.Exp(nativeResult1[j + i * _classNumber]);

Transformers\HashTests.cs (1)

369Assert.Equal(Math.Pow(2, 31), hashedCol.Type.GetItemType().GetKeyCount());

AdaptiveSingularSpectrumSequenceModeler.cs (36)

44public Double Ratio { get { return Math.Pow(Growth, 1d / TimeSpan); } } 664int evaluationLength = Math.Min(Math.Max(tMat.WindowSize, 200), k); 714error += Math.Abs(series[j] - temp); 757int evaluationLength = Math.Min(Math.Max(tMat.WindowSize, 200), k); 809error += Math.Abs(series[j] - temp); 855_info.ExponentialTrendFactor = Math.Abs(_alpha[0]); 867Double highFrequenceyBoundry = Math.PI / 2; 888if (roots[i].Magnitude > 1 && (Math.Abs(roots[i].Phase) <= eps || Math.Abs(Math.Abs(roots[i].Phase) - Math.PI) <= eps)) 897if (roots[i].Magnitude >= 1 && 2 * Math.PI / Math.Abs(roots[i].Phase) > _windowSize) 942if (Math.Abs(sortedComponents[i + 1].Phase - sortedComponents[i].Phase) > 0.05) 994if (Math.Abs(roots[ind].Phase) <= eps) 1003if (Math.Abs(roots[i].Phase) <= eps && 0.9 <= roots[i].Magnitude && i != ind1) 1021maxTrendMagnitude = Math.Min(1, _maxTrendRatio); 1030if (roots[i].Magnitude > 1 && Math.Abs(roots[i].Phase) <= eps) 1033maxTrendMagnitude = Math.Max(maxTrendMagnitude, roots[i].Magnitude); 1036maxNonTrendMagnitude = Math.Max(maxNonTrendMagnitude, roots[i].Magnitude); 1042maxTrendMagnitude = Math.Min(maxTrendMagnitude, _maxTrendRatio); 1046var smallTrendMagnitude = Math.Min(maxTrendMagnitude, (maxTrendMagnitude + 1) / 2); 1051if ((highFrequenceyBoundry < roots[i].Phase && roots[i].Phase < Math.PI - eps) || 1052(-Math.PI + eps < roots[i].Phase && roots[i].Phase < -highFrequenceyBoundry)) 1063if (Math.Abs(phase) <= eps) 1065else if (Math.Abs(phase - Math.PI) <= eps) 1067else if (Math.Abs(phase + Math.PI) <= eps) 1134for (i = Math.Max(0, len - _windowSize + 1); i < len; ++i) 1318var temp = (Single)(1f / Math.Sqrt(_windowSize)); 1383for (i = Math.Max(0, len - _windowSize); i < len; ++i) 1444for (j = Math.Max(0, i - _windowSize + 1); j < i; ++j, ++k) 1471sdEditor.Values[i] = (float)Math.Sqrt(sdEditor.Values[i]);

EigenUtils.cs (12)

21var n = (int)Math.Sqrt(count); 40eigenvalues[i] = eigenvalues[i] <= 0 ? (float)(0.0) : (float)Math.Sqrt(eigenvalues[i]); 45x = Math.Abs(x); 46y = Math.Abs(y); 54return y * (float)Math.Sqrt(1 + t * t); 59return x * (float)Math.Sqrt(1 + t * t); 65float xx = Math.Abs(x); 136scale += Math.Abs(d[k]); 160g = CopySign((float)Math.Sqrt(h), f); 360tst1 = Math.Abs(d[m]) + Math.Abs(d[m + 1]); 361tst2 = tst1 + Math.Abs(e[m]);

IidChangePointDetector.cs (2)

127InternalTransform.AlertThreshold = Math.Exp(InternalTransform.WindowSize * InternalTransform.LogPowerMartigaleBettingFunc(1 - options.Confidence / 100, InternalTransform.PowerMartingaleEpsilon)); 130InternalTransform.AlertThreshold = Math.Exp(InternalTransform.WindowSize * InternalTransform.LogMixtureMartigaleBettingFunc(1 - options.Confidence / 100));

PolynomialUtils.cs (10)

22return Math.Abs(x) <= _tol; 28var sqrtDelta = Math.Sqrt(Math.Abs(delta)); 157var temp = Math.Abs(Coefficients[i]); 236b = Math.Min(uLen, i + 1) - 1; 237a = i >= Math.Max(uLen, vLen) ? len - i : b + 1; 238c = Math.Max(0, i - uLen + 1); 343var k1 = Math.Abs(factors.ElementAt(0).Key); 344var k2 = Math.Abs(factors.ElementAt(factors.Count - 1).Key); 362ind = Math.Min(factors.Count - 1, ind);

RootCauseAnalyzer.cs (12)

378dst.Items[i].Score = GetFinalScore(scoreList[i].Surprise, Math.Abs(scoreList[i].ExplanatoryScore), beta); 617a = (1 - Math.Pow(2, -surprise)); 622b = (1 - Math.Pow(2, -ep)); 632double ep = anomalyPoint.Value - anomalyPoint.ExpectedValue == 0 ? 0 : Math.Abs((rootCausePoint.Value - rootCausePoint.ExpectedValue) / (anomalyPoint.Value - anomalyPoint.ExpectedValue)); 646if (Math.Abs(preTotal) < Math.Abs(parent) * _rootCauseThreshold) 651return Math.Abs(pre) / Math.Abs(current) > _anomalyPreDeltaThreshold; 656if (Math.Abs(total) < Math.Abs(parent) * _rootCauseThreshold) 720private double Log2(double val) => Double.IsNaN(val) ? 0 : Math.Log(val) / Math.Log(2);

SeasonalityDetector.cs (1)

192double threshold = randomnessValue / Math.Sqrt(timeSeriesLength);

SequentialAnomalyDetectionTransformBase.cs (12)

279return Math.Log(epsilon) + (epsilon - 1) * Math.Log(p); 294Double logP = Math.Log(p); 295return Math.Log(p * logP + 1 - p) - 2 * Math.Log(-logP) - logP; 443protected Double LatestMartingaleScore => Math.Exp(_logMartingaleValue); 484Double bandWidth = Math.Sqrt(2) * ((n == 1) ? 1 : Math.Sqrt(_sumSquaredDist) / n); 485bandWidth = Math.Max(bandWidth, 1e-6); 556rawScore = (float)Math.Abs(result.Values[1]); 574result.Values[2] = Math.Min(result.Values[2], 1 - result.Values[2]); 614result.Values[3] = Math.Exp(_logMartingaleValue);

SrCnnAnomalyDetectionBase.cs (3)

233score = Math.Min(score, 1); 234score = Math.Max(score, 0); 293return (float)(Math.Abs(mag - avgMag) / safeDivisor);

SrCnnEntireAnomalyDetector.cs (27)

507_minimumOriginValue = Math.Min(_minimumOriginValue, value); 508_maximumOriginValue = Math.Max(_maximumOriginValue, value); 514_std = Math.Sqrt((squareSum - (sum * sum) / values.Length) / values.Length); 566_magList[i] = Math.Sqrt(_fftRe[i] * _fftRe[i] + _fftIm[i] * _fftIm[i]); 569_magLogList[i] = Math.Log(_magList[i]); 582_spectralList[i] = Math.Exp(_magLogList[i] - _cumSumList[i]); 610_ifftMagList[i] = Math.Sqrt(_ifftRe[i] * _ifftRe[i] + _ifftIm[i] * _ifftIm[i]); 613AverageFilter(_ifftMagList, Math.Min(_ifftMagList.Length, _judgementWindowSize)); 614for (int i = 0; i <= Math.Min(length, _minimumScoreWindowSize); ++i) 616_cumSumList[i] = _cumSumList[Math.Min(length, _minimumScoreWindowSize) - 1]; 624score = Math.Min(score, _maximumScore); 625score = Math.Max(score, _minimumScore); 633var zscore = Math.Abs(values[i] - _mean) / _std; 705if (Math.Abs(safeDivisor) < _eps) 709return (Math.Abs(mag - avgMag) / safeDivisor); 779segments.Add(new Tuple<int, int>(start, Math.Max(start, cursor))); 882return Math.Max(Math.Min(expectedValue, value + boundMargin), value - boundMargin); 905int start = Math.Max(idx - step, 0); 906int end = Math.Min(data.Length - 1, idx + step); 920start = Math.Max(idx - step, 0); 921end = Math.Min(data.Length - 1, idx + step); 977int window = Math.Min(data.Length / 3, 512); 989trendSum += Math.Abs(_trends[i]); 1013_units[i] = averageTrendPart + Math.Abs(_trends[i]) * trendFraction; 1115if (Math.Floor(sensitivity) == sensitivity) 1135double distanceFactor = Math.Abs(exp - value) / unit;

SsaAnomalyDetectionBase.cs (2)

38return Math.Abs(actual - predicted); 48return predicted == 0 ? 0 : Math.Abs((actual - predicted) / predicted);

SsaChangePointDetector.cs (2)

137InternalTransform.AlertThreshold = Math.Exp(InternalTransform.WindowSize * InternalTransform.LogPowerMartigaleBettingFunc(1 - options.Confidence / 100, InternalTransform.PowerMartingaleEpsilon)); 140InternalTransform.AlertThreshold = Math.Exp(InternalTransform.WindowSize * InternalTransform.LogMixtureMartigaleBettingFunc(1 - options.Confidence / 100));

STL\LocalRegression.cs (3)

98double range = Math.Max(leftRange, rightRange); 129double range = Math.Max(leftRange, rightRange); 205absErrors[i] = Math.Abs(error);

STL\Loess.cs (2)

136double abs = Math.Abs(value); 149double abs = Math.Abs(value);

TrajectoryMatrix.cs (7)

128_shouldFftUsed = _windowSize * _k > (3 + 3 * Math.Log(_seriesLength)) * _seriesLength; 156return (Single)(coeff * Math.Sign(re) * Math.Sqrt(re * re + im * im)); 522b = Math.Min(uLen, i + 1) - 1; 523a = i >= Math.Max(uLen, vLen) ? len - i : b + 1; 524c = Math.Max(0, i - uLen + 1); 619int a = Math.Min(ue - us + 1, ve - vs + 1);

TimeSeriesDirectApi.cs (2)

1070Value = Math.Sin(2 * Math.PI + x),

Model\CodeGenTokenizer.cs (3)

401int index = addPrefixSpace ? Math.Max(0, textSpanToEncode.Length - 1) : textSpanToEncode.Length; 994retIndex = addPrefixSpace ? Math.Max(0, charsConsumed - 1) : charsConsumed; 1002return Math.Max(retIndex, 0);

Model\SentencePieceBaseModel.cs (5)

28BeginningOfSentenceId = Math.Max(0, modelProto.TrainerSpec.BosId); 30EndOfSentenceId = Math.Max(0, modelProto.TrainerSpec.EosId); 32UnknownId = Math.Max(0, modelProto.TrainerSpec.UnkId); 282charPoolArray ??= ArrayPool<char>.Shared.Rent(Math.Max(len, ApproximatedMaxEncodedBytesCount >> 1)); 620charPoolArray ??= ArrayPool<char>.Shared.Rent(Math.Max(len, ApproximatedMaxEncodedBytesCount >> 1));

Model\SentencePieceUnigramModel.cs (2)

53_minScore = Math.Min(_minScore, score); 54_maxScore = Math.Max(_maxScore, score);

Model\TiktokenTokenizer.cs (1)

841byte[] tmp = ArrayPool<byte>.Shared.Rent(Math.Max(utf8Bytes.Length * 2, requiredCapacity));

Model\Word.cs (4)

209int count = Math.Min(SymbolsCount, maxTokens); 224int count = Math.Min(SymbolsCount, maxTokens); 239int count = Math.Min(SymbolsCount, maxTokens); 253int count = Math.Min(SymbolsCount, maxTokens);

Tokenizer.cs (1)

237tokenCount = Math.Min(maxTokenCount, tokens.Tokens.Count);

Utils\Helpers.cs (2)

24T[] tmp = ArrayPool<T>.Shared.Rent(Math.Max(arrayPoolArray.Length * 2, requiredCapacity)); 61utf8Bytes = utf8Bytes.Slice(Math.Min(bytesLength, utf8Bytes.Length));

Utils\OrdinalUtf8StringComparer.cs (1)

29int minLength = Math.Min(x.Length, y.Length);

Utils\ValueStringBuilder.cs (2)

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

src\Common\tests\RetryHelper.cs (1)

15private static readonly Func<int, int> _defaultBackoffFunc = i => Math.Min(i * 100, 60_000);

BpeTests.cs (1)

326for (int i = 1; i < destinationBuffer.Length - 1; i += Math.Max(1, destinationBuffer.Length - 3)) // enough to test length 1, and destinationBuffer.Length - 2 only.

CodeGenTests.cs (1)

312for (int i = 1; i < destinationBuffer.Length - 1; i += Math.Max(1, destinationBuffer.Length - 3)) // enough to test length 1, and destinationBuffer.Length - 2 only.

EnglishRobertaTests.cs (1)

317for (int i = 1; i < destinationBuffer.Length - 1; i += Math.Max(1, destinationBuffer.Length - 3)) // enough to test length 1, and destinationBuffer.Length - 2 only.

LlamaTests.cs (5)

src\Common\tests\RetryHelper.cs (1)

15private static readonly Func<int, int> _defaultBackoffFunc = i => Math.Min(i * 100, 60_000);

src\Microsoft.ML.Tokenizers\Utils\Helpers.cs (2)

24T[] tmp = ArrayPool<T>.Shared.Rent(Math.Max(arrayPoolArray.Length * 2, requiredCapacity)); 61utf8Bytes = utf8Bytes.Slice(Math.Min(bytesLength, utf8Bytes.Length));

src\Microsoft.ML.Tokenizers\Utils\Helpers.netstandard.cs (2)

172Helpers.ArrayPoolGrow(ref destination, Math.Max(destination.Length, 4) * 2); 186Helpers.ArrayPoolGrow(ref destination, Math.Max(destination.Length, 3) * 2);

src\Microsoft.ML.Tokenizers\Utils\OrdinalUtf8StringComparer.cs (1)

29int minLength = Math.Min(x.Length, y.Length);

TiktokenTests.cs (1)

171for (int i = 1; i < destinationBuffer.Length - 1; i += Math.Max(1, destinationBuffer.Length - 3)) // enough to test length 1, and destinationBuffer.Length - 2 only.

AutoFormerV2\Anchors.cs (10)

46this.strides = strides != null ? strides : this.pyramidLevels.Select(x => (int)Math.Pow(2, x)).ToArray(); 47this.sizes = sizes != null ? sizes : this.pyramidLevels.Select(x => (int)Math.Pow(2, x + 2)).ToArray(); 49this.scales = scales != null ? scales : new double[] { Math.Pow(2, 0), Math.Pow(2, 1.0 / 3.0), Math.Pow(2, 2.0 / 3.0) }; 70var shape = ((imageShape + Math.Pow(2, x) - 1) / Math.Pow(2, x)).to_type(torch.int32); 98scales ??= new double[] { Math.Pow(2, 0), Math.Pow(2, 1.0 / 3.0), Math.Pow(2, 2.0 / 3.0) };

AutoFormerV2\Attention.cs (3)

51this.scale = System.Math.Pow(keyChannels, -0.5); 80var offset = new Tuple<int, int>(Math.Abs(points[i][0] - points[j][0]), Math.Abs(points[i][1] - points[j][1]));

AutoFormerV2\AutoFormerV2Backbone.cs (1)

94outChannels: embedChannels[Math.Min(iLayer + 1, embedChannels.Count - 1)],

AutoFormerV2\BasicLayer.cs (2)

66int hp = (int)Math.Ceiling((double)h / this.windowSize) * this.windowSize; 67int wp = (int)Math.Ceiling((double)w / this.windowSize) * this.windowSize;

AutoFormerV2\ObjectDetectionMetrics.cs (4)

162float xleft = Math.Max(bbox.Left, gt.Left); 163float yleft = Math.Max(bbox.Top, gt.Top); 164float xright = Math.Min(bbox.Left + bbox.Width, gt.Left + gt.Width); 165float yright = Math.Min(bbox.Top + bbox.Height, gt.Top + gt.Height);

NasBert\Modules\ActivationFunction.cs (2)

64private readonly double _alpha = Math.Sqrt(2 / Math.PI);

NasBert\Modules\ConvSeparable.cs (1)

28var std = Math.Sqrt((4 * (1.0 - dropout)) / (kernelSize * inChannels));

NasBert\Modules\Embedding\LearnedPositionalEmbedding.cs (1)

28ModelUtils.InitNormal(Embedding.weight, mean: 0, std: Math.Pow(EmbeddingDim, -0.5));

NasBert\Modules\Embedding\SinusoidalPositionalEmbedding.cs (1)

38var embedDouble = Math.Log(10000) / (halfDim - 1);

NasBert\Modules\MultiHeadAttention.cs (4)

74_scaling = Math.Pow(_headDim, -0.5); 112ModelUtils.InitXavierUniform(QProjection.weight, 1.0 / Math.Sqrt(2.0)); 113ModelUtils.InitXavierUniform(KProjection.weight, 1.0 / Math.Sqrt(2.0)); 114ModelUtils.InitXavierUniform(VProjection.weight, 1.0 / Math.Sqrt(2.0));

NasBert\Optimizers\BaseOptimizer.cs (1)

65return Math.Sqrt(Parameters

Roberta\Modules\AttentionSelf.cs (1)

57queryLayer.div_(Math.Sqrt(AttentionHeadSize));

Dracula\CMCountTable.cs (1)

237: base(Math.Max(labelCardinality, table.LabelCardinality))

Dracula\DictCountTable.cs (1)

182: base(Math.Max(labelCardinality, table.LabelCardinality))

Dracula\Featurizer.cs (1)

204logOdds[i] = (float)Math.Log(

Expression\BuiltinFunctions.cs (63)

Expression\CodeGen.cs (1)

661CallBin<R8>(Math.Pow);

Expression\LambdaBinder.cs (2)

809return Math.Pow(v1, v2); 1415args[i] = Convert(node.Args.Items[i].AsExpr, best.Kinds[Math.Min(i, ivMax)]);

LearnerFeatureSelection.cs (3)

147var score = Math.Abs(scoresValues[i]); 163score = Math.Abs(scoresValues[i]); 238var score = Math.Abs(scores[i]);

MutualInformationFeatureSelection.cs (1)

714score += _contingencyTable[i][j] / (double)_labels.Length * Math.Log(_contingencyTable[i][j] * (double)_labels.Length / ((double)_labelSums[i] * _featureSums[j]), 2);

RandomFourierFeaturizing.cs (1)

195RotationTerms[i] = (_rand.NextSingle() - (float)0.5) * (float)Math.PI;

Text\NgramTransform.cs (1)

306invDocFreqs[iinfo][i] = Math.Log(totalDocs / invDocFreqs[iinfo][i]);

Text\WordEmbeddingsExtractor.cs (1)

680int skippedLinesCount = Math.Max(1, _linesToSkip);

DnnRetrainTransform.cs (1)

817var d = numOfUnkDim > 0 ? Math.Pow(typeValueCount / valCount, 1.0 / numOfUnkDim) : 0;

ImageClassificationTrainer.cs (1)

253MinDelta = Math.Abs(minDelta);

Microsoft\VisualBasic\CompilerServices\LikeOperator.vb (1)

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

Microsoft\VisualBasic\CompilerServices\VBBinder.vb (5)

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))

Microsoft\VisualBasic\ErrObject.vb (1)

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

Microsoft\VisualBasic\FileIO\FileSystem.vb (1)

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

Microsoft\VisualBasic\Financial.vb (1)

5Imports System.Math

Diagnostics\VisualStudioVenusSpanMappingService.cs (1)

60sourceSpan = TextSpan.FromBounds(startPos, Math.Max(startPos, endPos));

DocumentOutline\DocumentOutlineView.xaml.cs (1)

342var croppedRenderWidth = Math.Min(item.RenderSize.Width, SymbolTree.RenderSize.Width / 4);

Extensions\DocumentExtensions.cs (1)

55var end = Math.Max(start, previousLine.End);

FindReferences\Entries\DocumentSpanEntry.cs (2)

236var firstLineNumber = Math.Max(0, lineNumber - AdditionalLineCountPerSide); 237var lastLineNumber = Math.Min(sourceText.Lines.Count - 1, lineNumber + AdditionalLineCountPerSide);

MoveStaticMembers\TypeNameItem.cs (1)

54for (var i = 0; i < Math.Min(xnames.Length, ynames.Length); i++)

Packaging\PackageInstallerServiceFactory.cs (1)

641for (int i = 0, n = Math.Min(split1.Length, split2.Length); i < n; i++)

ProjectSystem\MetadataReferences\VisualStudioMetadataReferenceManager.cs (1)

263while ((read = source.Read(buffer, 0, Math.Min(left, buffer.Length))) != 0)

StackTraceExplorer\StackFrameViewModel.cs (1)

116lineNumber = Math.Min(sourceText.Lines.Count, lineNumber);

SymbolSearch\VisualStudioSymbolSearchService.cs (2)

192bestRank = bestRank == null ? rank : Math.Max(bestRank.Value, rank); 194if (rank < RankThreshold && Math.Abs(bestRank.Value - rank) > 1)

Venus\CodeBlockEnumerator.cs (1)

43pceltFetched = Math.Min(celt, (uint)(_codeBlocks.Count - _currentElement));

Venus\ContainedDocument.cs (1)

1032var ch = char.ToLower(surfaceSnapshot[Math.Max(surfacePoint.Value - 1, 0)]);

Venus\ContainedDocument.DocumentServiceProvider.cs (2)

308var startLine = line.Snapshot.GetLineFromLineNumber(Math.Max(0, line.LineNumber - AdditionalLineCountPerSide)); 309var endLine = line.Snapshot.GetLineFromLineNumber(Math.Min(line.Snapshot.LineCount - 1, line.LineNumber + AdditionalLineCountPerSide));

Workspace\VisualStudioDocumentNavigationService.cs (2)

344=> Math.Min(documentLength, Math.Max(position, 0));

CodeModel\CSharpCodeModelService.cs (1)

1372lengthToStrip = Math.Min(lengthToStrip, line.GetLeadingWhitespace().Length);

PersistentStorage\AbstractPersistentStorageTests.cs (1)

84ThreadPool.SetMinThreads(Math.Max(workerThreads, NumThreads), completionPortThreads);

CommunicationsUtilities.cs (1)

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

FileUtilities.cs (1)

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

NodeEndpointOutOfProcBase.cs (1)

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

Concurrent\ConcurrentDictionary.cs (1)

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

Concurrent\ConcurrentQueue.cs (1)

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

NodeEndpointOutOfProcBase.cs (1)

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

src\libraries\shims\mscorlib\ref\mscorlib.cs (1)

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

netstandard.cs (1)

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

MS\Internal\MarkupCompiler\VersionHelper.cs (1)

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

src\Microsoft.DotNet.Wpf\src\PresentationCore\MS\Internal\Media\XamlSerializationHelper.cs (1)

430scaledInteger = Math.Floor( scaledValue ) ;

src\Microsoft.DotNet.Wpf\src\PresentationCore\System\Windows\Media\ParsersCommon.cs (2)

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

MS\Internal\AnimatedTypeHelpers.cs (17)

MS\Internal\FontCache\FontCacheUtil.cs (1)

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

MS\Internal\FontCache\FontFaceLayoutInfo.cs (2)

917int smaller = Math.Min(lastChar, firstChar); 918int larger = Math.Max(lastChar, firstChar);

MS\Internal\Generic\Span.cs (1)

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

MS\Internal\IListConverters.cs (4)

98List<double> list = new List<double>(Math.Min(256, value.Length / EstimatedCharCountPerItem + 1)); 141List<ushort> list = new List<ushort>(Math.Min(256, value.Length / EstimatedCharCountPerItem + 1)); 182List<bool> list = new List<bool>(Math.Min(256, value.Length / EstimatedCharCountPerItem + 1)); 224List<Point> list = new List<Point>(Math.Min(256, value.Length / EstimatedCharCountPerItem + 1));

MS\Internal\Ink\Bezier.cs (5)

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

MS\Internal\Ink\CuspData.cs (4)

471rMin = Math.Min(rMin, a); 472rMax = Math.Max(a, rMax); 500_dist = Math.Abs(rR) + Math.Abs(rB);

MS\Internal\Ink\EllipticalNodeOperations.cs (12)

29_radius = Math.Max(_radii.Width, _radii.Height); 116double distance = Math.Sqrt(distanceSquared); 137rad *= Math.Sqrt(1 - rSinSquared); 138spine *= Math.Sqrt(rSinSquared); 617radius = Math.Abs(nearest.Y); 621radius = Math.Abs(nearest.X); 720double tmp = Math.Sqrt(B*B-4.0f * A * C); 727findex = Math.Min(s1, s2); 754findex = Math.Abs(Math.Min(s1, s2) - 0d) < Math.Abs(Math.Max(s1, s2) - 1d) ? 0d : 1d;

MS\Internal\Ink\ErasingStroke.cs (2)

182Math.Min(lastFragment.BeginFIndex, fragment.BeginFIndex), 183Math.Max(lastFragment.EndFIndex, fragment.EndFIndex));

MS\Internal\Ink\InkSerializedFormat\GorillaCodec.cs (8)

147uint ulAbsMaxDelDel = (uint)Math.Max(MathHelper.AbsNoThrow(minDelDel), MathHelper.AbsNoThrow(maxDelDel)); 149uint ulAbsMax = (uint)Math.Max(MathHelper.AbsNoThrow(minVal), MathHelper.AbsNoThrow(maxVal)); 220maxByte = Math.Max(input[n], maxByte); 221maxShort = Math.Max((ushort)shortReader.ReadUInt16Reverse(Native.BitsPerShort), maxShort); 231maxByte = Math.Max(input[n], maxByte); 232maxShort = Math.Max((ushort)shortReader.ReadUInt16Reverse(Native.BitsPerShort), maxShort); 238maxByte = Math.Max(input[n], maxByte); 280ulAbsMax = (uint)Math.Max(MathHelper.AbsNoThrow(minInt), MathHelper.AbsNoThrow(maxInt));

MS\Internal\Ink\InkSerializedFormat\InkSerializer.cs (3)

1391double dAngle = (tdrd.Transform[0] / 100) * (Math.PI / 180); 1393M00 = M11 = Math.Cos(dAngle); 1394M01 = Math.Sin(dAngle);

MS\Internal\Ink\InkSerializedFormat\SerializationHelper.cs (1)

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

MS\Internal\Ink\Lasso.cs (6)

150DoubleUtil.GreaterThanOrClose(point.X, Math.Min(prevLassoPoint.X, lassoPoint.X)) && 151DoubleUtil.LessThanOrClose(point.X, Math.Max(prevLassoPoint.X, lassoPoint.X))) 160if (DoubleUtil.GreaterThanOrClose(point.X, Math.Max(prevLassoPoint.X, lassoPoint.X))) 165else if (DoubleUtil.GreaterThanOrClose(point.X, Math.Min(prevLassoPoint.X, lassoPoint.X))) 516return (Math.Abs(vector.X) < MinDistance && Math.Abs(vector.Y) < MinDistance);

MS\Internal\Ink\Renderer.cs (1)

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

MS\Internal\Ink\StrokeNode.cs (17)

MS\Internal\Ink\StrokeNodeOperations.cs (2)

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

MS\Internal\Ink\StrokeNodeOperations2.cs (1)

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

MS\Internal\Ink\StrokeRenderer.cs (27)

86double delta = Math.Abs(GetAngleDeltaFromLast(strokeNode.PreviousPosition, strokeNode.Position, ref lastAngle)); 106if ((Math.Min(prevArea, currArea) / Math.Max(prevArea, currArea)) <= 0.70d) 248double maxExtent = Math.Max(drawingAttributes.Height, drawingAttributes.Width); 249percentIntersect += Math.Min(4.99999d, ((maxExtent / 20d) * 5d)); 517bool directionChangedOverAbsoluteThreshold = Math.Abs(delta) > 90d && Math.Abs(delta) < (360d - 90d); 518bool directionChangedOverOverlapThreshold = overlap && !(ignorePressure || strokeNode.PressureFactor == 1f) && Math.Abs(delta) > 30d && Math.Abs(delta) < (360d - 30d); 527if ((Math.Min(prevArea, currArea) / Math.Max(prevArea, currArea)) <= 0.90d) 832double intersectLeft = Math.Max(rect1.Left, rect2.Left); 833double intersectTop = Math.Max(rect1.Top, rect2.Top); 834double intersectWidth = Math.Max((double)(Math.Min(rect1.Right, rect2.Right) - intersectLeft), (double)0); 835double intersectHeight = Math.Max((double)(Math.Min(rect1.Bottom, rect2.Bottom) - intersectTop), (double)0); 845double minArea = Math.Min(rect1Area, rect2Area); 1048angle = Math.PI / 2.0; 1052angle = Math.PI * 3.0 / 2.0; 1063angle = Math.PI; 1070angle = Math.Atan(dy / dx) + Math.PI; 1074angle = Math.Atan(dy / dx) + (2 * Math.PI); 1078angle = Math.Atan(dy / dx); 1083angle = angle * 180 / Math.PI;

MS\Internal\IO\Packaging\DeobfuscatingStream.cs (1)

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

MS\Internal\IO\Packaging\NetStream.cs (7)

145count = Math.Min(bytesAvailable, count); // don't return more than they requested, and don't return more than is available 729bytesAvailable = Math.Min(block.Length, (int)(data.End - block.Offset)); 894_length = (int)(Math.Max(_offset + _length, b._offset + b._length) - _offset); 951bytesAvailable = (int)Math.Min(block.Length, _highWaterMark - block.Offset); 1015dataAvailable = (int)Math.Min(block.Length, _highWaterMark - block.Offset); 1047dataAvailable = (int)Math.Min(block.Length, _highWaterMark - block.Offset); 1145block.Length = (int)Math.Min(block.Length, _fullStreamLength - block.Offset);

MS\Internal\Media\XamlSerializationHelper.cs (1)

430scaledInteger = Math.Floor( scaledValue ) ;

MS\Internal\Media3D\GeneralTransform2DTo3DTo2D.cs (19)

495if (!((Math.Max(visEdgeStart.X, visEdgeEnd.X) < Math.Min(uv1.X, uv2.X)) || 496(Math.Min(visEdgeStart.X, visEdgeEnd.X) > Math.Max(uv1.X, uv2.X)) || 497(Math.Max(visEdgeStart.Y, visEdgeEnd.Y) < Math.Min(uv1.Y, uv2.Y)) || 498(Math.Min(visEdgeStart.Y, visEdgeEnd.Y) > Math.Max(uv1.Y, uv2.Y)))) 599if (Math.Abs(visUV1.X - visUV2.X) > Math.Abs(visUV1.Y - visUV2.Y)) 913if (!((Math.Max(visEdgeStart.X, visEdgeEnd.X) < Math.Min(uv1.X, uv2.X)) || 914(Math.Min(visEdgeStart.X, visEdgeEnd.X) > Math.Max(uv1.X, uv2.X)) || 915(Math.Max(visEdgeStart.Y, visEdgeEnd.Y) < Math.Min(uv1.Y, uv2.Y)) || 916(Math.Min(visEdgeStart.Y, visEdgeEnd.Y) > Math.Max(uv1.Y, uv2.Y)))) 1083closestIntersection = ((currClosest - edges[i]._p1Transformed).Length / Math.Sqrt(denom) *

MS\Internal\Media3D\LineUtil.cs (4)

281maxvalue = Math.Max(maxvalue,m[i,j]*m[i,j]); 284maxvalue = Math.Sqrt(maxvalue); 333double root = Math.Sqrt(1+tau*tau); 336_c = 1/Math.Sqrt(1+t*t);

MS\Internal\Media3D\M3DUtil.cs (2)

374return radians*(180.0/Math.PI); 379return degrees*(Math.PI/180.0);

MS\Internal\Shaping\CompositeFontFamily.cs (2)

117return Math.Round(_fontInfo.Baseline * emSize); 148return Math.Round(_fontInfo.LineSpacing * emSize);

MS\Internal\Shaping\TypefaceMap.cs (4)

176cch = Math.Min(cch, itemSpanRider.Length); 177cch = Math.Min(cch, typefaceIndexSpanRider.Length); 221int cch = Math.Min(cchRange - ich, typefaceIndexSpanRider.Length); 387int cch = Math.Min(unicodeString.Length - ich, typefaceSpanRider.Length);

MS\Internal\TextFormatting\Bidi.cs (9)

1604lengthResolved = Math.Max(startOfNeutrals, startOfDelayed) == PositionInvalid ? 1606((Math.Min(startOfNeutrals, startOfDelayed) == PositionInvalid) ? 1607(Math.Max(startOfNeutrals, startOfDelayed)) : 1608(Math.Min(startOfNeutrals, startOfDelayed))); 1838cchText = Math.Min(cchText, index); 2400sor = Helper.IsOdd(Math.Max(baseLevel, levels[runStart])) ? 2405sor = Helper.IsOdd(Math.Max(lastRunLevel, levels[runStart])) ? 2415eor = Helper.IsOdd(Math.Max(levels[runStart], baseLevel)) ? 2430eor = Helper.IsOdd(Math.Max(levels[runStart], levels[runLimits[runNumber-1] + 1])) ?

MS\Internal\TextFormatting\FormatSettings.cs (3)

135_maxLineWidth = Math.Max(maxLineWidth, 0); 172formatWidth = Math.Max(formatWidth, 0); 173formatWidth = Math.Min(formatWidth, Constants.IdealInfiniteWidth);

MS\Internal\TextFormatting\FullTextLine.cs (5)

1370offsetToNextCaretStopIndex = Math.Min(Length, lsrun.Length - caretStopIndex + lsrun.OffsetToFirstCp + _cpFirst); 1412lscpVisisble = Math.Min(lscpVisisble, _metrics._lscpLim - 1); 1644int lscpEndInSubline = Math.Min( 1987int cch = Math.Min(plsrunSpanRider.Length, cchLeft); 2073cch = Math.Min(cch, cchLeft);

MS\Internal\TextFormatting\FullTextState.cs (1)

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

MS\Internal\TextFormatting\LexicalChunk.cs (2)

84return ich - cchLast + Math.Min(cchLast, lsdcp - lsdcpLast); 92return ich - cchLast + Math.Min(cchLast, lsdcp - lsdcpLast);

MS\Internal\TextFormatting\LineServicesCallbacks.cs (14)

425lstTextMetrics.dvAscent = (int)Math.Round(typeface.Baseline(store.Pap.EmSize, Constants.DefaultIdealToReal, store.Settings.TextSource.PixelsPerDip, fullText.TextFormattingMode)); 426lstTextMetrics.dvMultiLineHeight = (int)Math.Round(typeface.LineSpacing(store.Pap.EmSize, Constants.DefaultIdealToReal, store.Settings.TextSource.PixelsPerDip, fullText.TextFormattingMode)); 686ulInfo.dvpFirstUnderlineOffset = (int)Math.Round(lsrun.EmSize * -underlinePositionInEm); 687ulInfo.dvpFirstUnderlineSize = (int)Math.Round(lsrun.EmSize * underlineThicknessInEm); 740stInfo.dvpLowerStrikethroughOffset = (int)Math.Round(lsrun.EmSize * strikeThroughPositionInEm); 741stInfo.dvpLowerStrikethroughSize = (int)Math.Round(lsrun.EmSize * strikeThroughThicknessInEm); 935int baselineTop = ptOrigin.y + (int)Math.Round(lsrun.EmSize * strikeThroughPositionInEm); 936int overlineTop = baselineTop - (lsrun.BaselineOffset - (int)Math.Round(lsrun.EmSize * strikeThroughThicknessInEm)); 1242penThickness = Math.Abs(penThickness); 1318drawingPenThickness /= Math.Abs(unitValue); 1987int expandedBy = Math.Max(0, interWordAdjustTo - adjustedCharWidth); 1994pplsAdjustRight[0][i] = Math.Max(0, adjustedCharWidth - interWordAdjustTo); 2120pplsCompressionRight[0][igi + i] = Math.Max(0, glyphAdvance - interWordCompressTo); 2253int expandedBy = Math.Max(0, interWordExpandTo - glyphAdvance);

MS\Internal\TextFormatting\LineServicesRun.cs (2)

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

MS\Internal\TextFormatting\SimpleTextLine.cs (10)

288realHeight = Math.Max(realHeight, run.Height); 289realAscent = Math.Max(realAscent, run.Baseline); 290realDescent = Math.Max(realDescent, run.Height - run.Baseline); 325_height = formatter.IdealToReal((int)Math.Round(pap.DefaultTypeface.LineSpacing(pap.EmSize, Constants.DefaultIdealToReal, PixelsPerDip, _settings.TextFormattingMode)), PixelsPerDip); 326_baselineOffset = formatter.IdealToReal((int)Math.Round(pap.DefaultTypeface.Baseline(pap.EmSize, Constants.DefaultIdealToReal, PixelsPerDip, _settings.TextFormattingMode)), PixelsPerDip); 360_idealOffsetUnRounded = (int)Math.Round((paragraphWidth - idealWidthAtTrailing) * 0.5); 837int first = Math.Max(ich, dcp) + _cpFirst; 838int afterLast = Math.Min(ich + run.Length, dcp + textLength) + _cpFirst; 1205cpVisible = Math.Max(cpRunStart, cp); 1237cpVisible = Math.Min(cpRunEnd, cp);

MS\Internal\TextFormatting\TextFormatterImp.cs (6)

648return Math.Round(value * pixelsPerDip, midpointRounding) / pixelsPerDip; 691value = Math.Max(value, Constants.DefaultIdealToReal); 702int value = (int)Math.Round(i * ToIdeal); 706value = Math.Max(value, 1); 723int value = (int)Math.Floor(i * ToIdeal); 727value = Math.Max(value, 1);

MS\Internal\TextFormatting\TextMarkerSource.cs (1)

177Math.Min(_characterArray.Length, textSourceCharacterIndexLimit)

MS\Internal\TextFormatting\TextMetrics.cs (5)

169int lscpFirstIndependence = Math.Max( 189_baselineOffset = (int)Math.Round( 200_textAscent = (int)Math.Round(pap.DefaultTypeface.Baseline(pap.EmSize, Constants.DefaultIdealToReal, _pixelsPerDip, fullText.TextFormattingMode)); 201_textHeight = (int)Math.Round(pap.DefaultTypeface.LineSpacing(pap.EmSize, Constants.DefaultIdealToReal, _pixelsPerDip, fullText.TextFormattingMode)); 252_paragraphToText = (int)Math.Round((paragraphWidth + _textStart - _textWidthAtTrailing) * 0.5);

MS\Internal\TextFormatting\TextProperties.cs (1)

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

MS\Internal\TextFormatting\TextRunCacheImp.cs (3)

188looseCharLength = (int)Math.Round(TextStore.TypicalCharactersPerLine * 0.25); 211int lookAheadLimit = Math.Min(runLength, looseCharLength + TextStore.TypicalCharactersPerLine); 237looseCharLength = Math.Min(runLength, endOffset);

MS\Internal\TextFormatting\TextShapeableCharacters.cs (2)

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

MS\Internal\TextFormatting\TextStore.cs (16)

508int effectedRangeStart = Math.Max(cpFetched - offset, bounds[0].Position); 509int effectedRangeEnd = Math.Min(cpFetched - offset + runInfo.Length, bounds[bounds.Length - 1].Position); 519int currentRangeEnd = Math.Min(bounds[i].Position, effectedRangeEnd); 553currentPosition = Math.Max(currentPosition, bounds[i + 1].Position); 1121int runLength = Math.Min(span.length, cchToAdd - ichRun); 1209int first = limit - Math.Min(charRange.Length, limitCp - firstCp); 1292int spanLength = Math.Min(runInfoSpanRider.Length, textEffectsSpanRider.Length); 1293int ichEnd = Math.Min(ichRun + spanLength, cchUniform); 1563(int)Math.Round(realToIdeal * runInfo.TextRun.Properties.FontRenderingEmSize), 1718(int)Math.Round(realToIdeal * runInfo.TextRun.Properties.FontRenderingEmSize), 1957textTop = Math.Max(textTop, lsrun.BaselineOffset); 1958textBottom = Math.Max(textBottom, lsrun.Descent); 1978textBottom = Math.Max(textBottom, lsrun.Height + top); 1982textBottom = Math.Max(textBottom, lsrun.Height + textTop); 2046cellAscent = Math.Max(cellAscent, lsrun.BaselineOffset - move); 2047cellDescent = Math.Max(cellDescent, lsrun.Descent + move);

MS\Internal\TextFormatting\ThousandthOfEmRealDoubles.cs (1)

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

src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\FloatUtil.cs (6)

33float eps = ((float)Math.Abs(a) + (float)Math.Abs(b) + 10.0f) * FLT_EPSILON; 44return (float)Math.Abs(a - 1.0f) < 10.0f * FLT_EPSILON; 52return (float)Math.Abs(a) < 10.0f * FLT_EPSILON; 61return Math.Abs(denominator) <= Math.Abs(numerator) * INVERSE_FLT_MAX_PRECISION;

src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\Ink\BitStream.cs (1)

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

System\Windows\Ink\IncrementalHitTester.cs (4)

824weight += Math.Sqrt(da.Width*da.Width + da.Height*da.Height) / 2.0f; 829weight += Math.Sqrt(spine.LengthSquared) / 2.0f; 834weight += Math.Sqrt(da.Width*da.Width + da.Height*da.Height) / 2.0f; 839weight += Math.Sqrt(spine.LengthSquared) / 2.0f;

System\Windows\Ink\Stroke.cs (8)

230double min = Math.Min(shapeBoundingBox.Width, shapeBoundingBox.Height); 231tolerance = Math.Log10(min + min); 354return Math.Sqrt(spine.LengthSquared); 747Math.Ceiling(cutAt[cutAt.Length - 1].EndFIndex) <= sourceStylusPoints.Count - 1); 803Math.Ceiling(cutAt[cutAt.Length - 1].EndFIndex) <= sourceStylusPoints.Count - 1); 855? 0 : (int)Math.Floor(beginFIndex); 859? (sourceStylusPoints.Count - 1) : (int)Math.Ceiling(endFIndex); 913double ceiling = Math.Ceiling(endFIndex);

System\Windows\Ink\Stroke2.cs (4)

377selectedDA.Height = Math.Max(selectedDA.Height, DrawingAttributes.DefaultHeight); 378selectedDA.Width = Math.Max(selectedDA.Width, DrawingAttributes.DefaultWidth); 676double newWidth = Math.Sqrt(w.X * w.X + w.Y * w.Y); 677double newHeight = Math.Sqrt(h.X * h.X + h.Y * h.Y);

System\Windows\Input\AngleUtil.cs (2)

13return degrees * Math.PI / 180.0; 21return radians * 180.0 / Math.PI;

System\Windows\Input\ManipulationLogic.cs (1)

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

System\Windows\Input\MouseDevice.cs (2)

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

System\Windows\Input\Stylus\Common\StylusPointCollection.cs (4)

524output[x] = (int)Math.Round(stylusPoint.X * StrokeCollectionSerializer.AvalonToHimetricMultiplier); 525output[x + 1] = (int)Math.Round(stylusPoint.Y * StrokeCollectionSerializer.AvalonToHimetricMultiplier); 593output[0][b] = (int)Math.Round(stylusPoint.X * StrokeCollectionSerializer.AvalonToHimetricMultiplier); 594output[1][b] = (int)Math.Round(stylusPoint.Y * StrokeCollectionSerializer.AvalonToHimetricMultiplier);

System\Windows\Input\Stylus\Pointer\PointerFlickEngine.cs (5)

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

System\Windows\Input\Stylus\Pointer\PointerLogic.cs (7)

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

System\Windows\Input\Stylus\Pointer\PointerStylusPlugInManager.cs (2)

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

System\Windows\Input\Stylus\Pointer\PointerStylusPointPropertyInfoHelper.cs (1)

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

System\Windows\Input\Stylus\Pointer\PointerTabletDevice.cs (6)

122Size mouseDoubleTapDefault = new Size(Math.Max(1, MS.Win32.SafeSystemMetrics.DoubleClickDeltaX / 2), 123Math.Max(1, MS.Win32.SafeSystemMetrics.DoubleClickDeltaY / 2)); 133_doubleTapSize = new Size((int)Math.Round((ScreenSize.Width * DoubleTapDelta) / dwXValue), 134(int)Math.Round((ScreenSize.Height *DoubleTapDelta) / dwYValue)); 138_doubleTapSize.Width = Math.Max(mouseDoubleTapDefault.Width, _doubleTapSize.Width); 139_doubleTapSize.Height = Math.Max(mouseDoubleTapDefault.Height, _doubleTapSize.Height);

System\Windows\Input\Stylus\Wisp\PenContexts.cs (3)

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

System\Windows\Input\Stylus\Wisp\WispLogic.cs (6)

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

System\Windows\Input\Stylus\Wisp\WispStylusDevice.cs (2)

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

System\Windows\Input\Stylus\Wisp\WispTabletDevice.cs (12)

271Size mouseDragDefault = new Size(Math.Max(1, SafeSystemMetrics.DragDeltaX / 2), 272Math.Max(1, SafeSystemMetrics.DragDeltaY / 2)); 273Size mouseDoubleTapDefault = new Size(Math.Max(1, SafeSystemMetrics.DoubleClickDeltaX / 2), 274Math.Max(1, SafeSystemMetrics.DoubleClickDeltaY / 2)); 284_cancelSize = new Size((int)Math.Round((ScreenSize.Width * stylusLogic.CancelDelta) / dwXValue), 285(int)Math.Round((ScreenSize.Height * stylusLogic.CancelDelta) / dwYValue)); 289_cancelSize.Width = Math.Max(mouseDragDefault.Width, _cancelSize.Width); 290_cancelSize.Height = Math.Max(mouseDragDefault.Height, _cancelSize.Height); 292_doubleTapSize = new Size((int)Math.Round((ScreenSize.Width * stylusLogic.DoubleTapDelta) / dwXValue), 293(int)Math.Round((ScreenSize.Height * stylusLogic.DoubleTapDelta) / dwYValue)); 297_doubleTapSize.Width = Math.Max(mouseDoubleTapDefault.Width, _doubleTapSize.Width); 298_doubleTapSize.Height = Math.Max(mouseDoubleTapDefault.Height, _doubleTapSize.Height);

System\Windows\InterOp\HwndPointerInputProvider.cs (2)

326originOffsetX = (int)Math.Round(originTabletCoord.X); 327originOffsetY = (int)Math.Round(originTabletCoord.Y);

System\Windows\InterOp\HwndSource.cs (2)

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

System\Windows\InterOp\HwndTarget.cs (4)

776(float)(Math.Ceiling((double)(_hwndClientRectInScreenCoords.right - _hwndClientRectInScreenCoords.left))), 777(float)(Math.Ceiling((double)(_hwndClientRectInScreenCoords.bottom - _hwndClientRectInScreenCoords.top)))); 1581(float)(Math.Ceiling((double)(_hwndClientRectInScreenCoords.right - _hwndClientRectInScreenCoords.left))), 1582(float)(Math.Ceiling((double)(_hwndClientRectInScreenCoords.bottom - _hwndClientRectInScreenCoords.top))));

System\Windows\Markup\XmlLanguage.cs (1)

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

System\Windows\Media\Animation\BackEase.cs (4)

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

System\Windows\Media\Animation\BounceEase.cs (7)

81double bounces = Math.Max(0.0, (double)Bounces); 91double pow = Math.Pow(bounciness, bounces); 104double bounceAtT = Math.Log(-unitAtT * (1.0-bounciness) + 1.0, bounciness); 105double start = Math.Floor(bounceAtT); 110double startTime = (1.0 - Math.Pow(bounciness, start)) / (oneMinusBounciness * sumOfUnits); 111double endTime = (1.0 - Math.Pow(bounciness, end)) / (oneMinusBounciness * sumOfUnits); 117double amplitude = Math.Pow(1.0 / bounciness, (bounces - start));

System\Windows\Media\Animation\CircleEase.cs (3)

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

System\Windows\Media\Animation\Clock.cs (3)

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

System\Windows\Media\Animation\ClockGroup.cs (1)

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

System\Windows\Media\Animation\DoubleAnimationUsingPath.cs (2)

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

System\Windows\Media\Animation\ElasticEase.cs (7)

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

System\Windows\Media\Animation\ExponentialEase.cs (2)

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

System\Windows\Media\Animation\KeySpline.cs (2)

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

System\Windows\Media\Animation\PowerEase.cs (2)

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

System\Windows\Media\Animation\SineEase.cs (2)

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

System\Windows\Media\ArcSegment.cs (1)

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

System\Windows\Media\ByteStreamGeometryContext.cs (2)

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

System\Windows\Media\Color.cs (2)

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

System\Windows\Media\Effects\DropShadowEffect.cs (3)

39double direction = Math.PI/180 * Direction; 40double offsetX = depth * Math.Cos(direction); 41double offsetY = depth * Math.Sin(direction);

System\Windows\Media\EllipseGeometry.cs (14)

85currentCenter.X - Math.Abs(currentRadiusX), 86currentCenter.Y - Math.Abs(currentRadiusY), 872.0 * Math.Abs(currentRadiusX), 882.0 * Math.Abs(currentRadiusY)); 151strokeThickness = Math.Abs(pen.Thickness); 155center.X - Math.Abs(radiusX)-0.5*strokeThickness, 156center.Y - Math.Abs(radiusY)-0.5*strokeThickness, 1572.0 * Math.Abs(radiusX)+strokeThickness, 1582.0 * Math.Abs(radiusY)+strokeThickness); 236double area = Math.Abs(RadiusX * RadiusY) * Math.PI; 242area *= Math.Abs(transform.Value.Determinant); 348radiusX = Math.Abs(radiusX); 349radiusY = Math.Abs(radiusY);

System\Windows\Media\FamilyTypeface.cs (1)

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

System\Windows\Media\FormattedText.cs (21)

System\Windows\Media\GlyphRun.cs (4)

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

System\Windows\Media\GlyphsSerializer.cs (6)

52Math.Max( 178int roundedShapingAdvance = (int)Math.Round(_idealAdvanceTotal + shapingAdvance - _currentAdvanceTotal); 179int roundedFontAdvance = (int)Math.Round(fontAdvance); 200int offset = (int)Math.Round(_offsets[glyph].X * _milToEm); 208offset = (int)Math.Round(_offsets[glyph].Y * _milToEm); 274lastCaretStop = Math.Min(i | 3, _caretStops.Count - 1);

System\Windows\Media\GlyphTypeface.cs (3)

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

System\Windows\Media\Imaging\BitmapDownload.cs (1)

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

System\Windows\Media\Imaging\BitmapPalette.cs (1)

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

System\Windows\Media\Imaging\BitmapSource.cs (2)

463return new Size(Math.Max(0, GetWidthInternal()), 464Math.Max(0, GetHeightInternal()));

System\Windows\Media\Imaging\TransformedBitmap.cs (6)

116scaleX = Math.Abs(m.M11); 117scaleY = Math.Abs(m.M22); 135scaleX = Math.Abs(m.M12); 136scaleY = Math.Abs(m.M21); 175uint width = Math.Max(1, (uint)(scaleX * _source.PixelWidth + 0.5)); 176uint height = Math.Max(1, (uint)(scaleY * _source.PixelHeight + 0.5));

System\Windows\Media\LinearGradientBrush.cs (3)

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

System\Windows\Media\MatrixStack.cs (4)

81_highWaterMark = Math.Max(_highWaterMark, _size); 119_highWaterMark = Math.Max(_highWaterMark, _size); 149_highWaterMark = Math.Max(_highWaterMark, _size); 192int newSize = Math.Max(_highWaterMark, s_initialSize);

System\Windows\Media\MediaContext.cs (4)

97int sqrt = (int) Math.Sqrt(number); 566nextTickNeeded = TimeSpan.FromTicks(Math.Max(nextTickNeeded.Ticks, minimumDelay.Ticks)); 745_animationRenderRate = Math.Max(_adjustedRefreshRate, _timeManager.GetMaxDesiredFrameRate()); 797_animationRenderRate = Math.Min(_animationRenderRate, 1000);

System\Windows\Media\ParsersCommon.cs (2)

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

System\Windows\Media\RectangleGeometry.cs (9)

189strokeThickness = Math.Abs(pen.Thickness); 283double area = Math.Abs(rect.Width * rect.Height); 286area -= Math.Abs(radiusX * radiusY) * (4.0 - Math.PI); 292area *= Math.Abs(transform.Value.Determinant); 464radiusX = Math.Min(rect.Width * (1.0 / 2.0), Math.Abs(radiusX)); 465radiusY = Math.Min(rect.Height * (1.0 / 2.0), Math.Abs(radiusY));

System\Windows\Media\RenderData.cs (1)

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

System\Windows\Media\textformatting\CharacterBufferReference.cs (1)

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

System\Windows\Media\Typeface.cs (2)

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

System\Windows\Media\VisualCollection.cs (1)

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

System\Windows\Media\VisualProxy.cs (1)

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

System\Windows\Media3D\AxisAngleRotation3D.cs (4)

120Math.E, Math.PI, Math.E * Math.PI, 55.0

System\Windows\Media3D\OrthographicCamera.cs (1)

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

System\Windows\Media3D\PerspectiveCamera.cs (2)

77double halfWidthDepthRatio = Math.Tan(fov/2); 125double halfWidthDepthRatio = Math.Tan(fov/2);

System\Windows\Media3D\Quaternion.cs (34)

69double angleInRadians = angleInDegrees * (Math.PI / 180.0); 73Vector3D v = (axisOfRotation / length) * Math.Sin(0.5 * angleInRadians); 77_w = Math.Cos(0.5 * angleInRadians); 141double msin = Math.Sqrt(_x*_x + _y*_y + _z*_z); 150double maxcoeff = Math.Max(Math.Abs(_x),Math.Max(Math.Abs(_y),Math.Abs(_z))); 154msin = Math.Sqrt(x*x + y*y + z*z); 160return Math.Atan2(msin,mcos) * (360.0 / Math.PI); 240double rmax = 1.0/Max(Math.Abs(_x), 241Math.Abs(_y), 242Math.Abs(_z), 243Math.Abs(_w)); 251double normInverse = 1.0 / Math.Sqrt(norm2); 425double max = Math.Max(Math.Max(Math.Abs(_x),Math.Abs(_y)), 426Math.Max(Math.Abs(_z),Math.Abs(_w))); 433double smallLength = Math.Sqrt(x*x+y*y+z*z+w*w); 437return Math.Sqrt(norm2); 541double theta = t * Math.PI; 543scaleFrom = Math.Cos(theta); 544scaleTo = Math.Sin(theta); 549double omega = Math.Acos(cosOmega); 550double sinOmega = Math.Sqrt(1.0 - cosOmega*cosOmega); 551scaleFrom = Math.Sin((1.0 - t) * omega) / sinOmega; 552scaleTo = Math.Sin(t * omega) / sinOmega; 560double lengthOut = lengthFrom * Math.Pow(lengthTo/lengthFrom, t);

System\Windows\Media3D\Ray3DHitTestResult.cs (1)

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

System\Windows\Media3D\Rect3D.cs (18)

76_x = Math.Min(point1._x, point2._x); 77_y = Math.Min(point1._y, point2._y); 78_z = Math.Min(point1._z, point2._z); 79_sizeX = Math.Max(point1._x, point2._x) - _x; 80_sizeY = Math.Max(point1._y, point2._y) - _y; 81_sizeZ = Math.Max(point1._z, point2._z) - _z; 417double x = Math.Max(_x, rect._x); 418double y = Math.Max(_y, rect._y); 419double z = Math.Max(_z, rect._z); 420_sizeX = Math.Min(_x + _sizeX, rect._x + rect._sizeX) - x; 421_sizeY = Math.Min(_y + _sizeY, rect._y + rect._sizeY) - y; 422_sizeZ = Math.Min(_z + _sizeZ, rect._z + rect._sizeZ) - z; 455double x = Math.Min(_x, rect._x); 456double y = Math.Min(_y, rect._y); 457double z = Math.Min(_z, rect._z); 458_sizeX = Math.Max(_x + _sizeX, rect._x + rect._sizeX) - x; 459_sizeY = Math.Max(_y + _sizeY, rect._y + rect._sizeY) - y; 460_sizeZ = Math.Max(_z + _sizeZ, rect._z + rect._sizeZ) - z;

System\Windows\Media3D\Vector3D.cs (11)

60return Math.Sqrt(_x * _x + _y * _y + _z * _z); 85double m = Math.Abs(_x); 86double absy = Math.Abs(_y); 87double absz = Math.Abs(_z); 101double length = Math.Sqrt(_x * _x + _y * _y + _z * _z); 167theta = Math.PI - 2.0 * Math.Asin((-vector1 - vector2).Length / 2.0); 171theta = 2.0 * Math.Asin((vector1 - vector2).Length / 2.0); 463return new Size3D(Math.Abs(vector._x), Math.Abs(vector._y), Math.Abs(vector._z));

System\Windows\UIElement.cs (2)

1086newValue = Math.Round(value * dpiScale) / dpiScale; 1097newValue = Math.Round(value);

Microsoft\Win32\CommonDialog.cs (2)

294(int)Math.Round(x), 295(int)Math.Round(y), // new X and Y positions

MS\Internal\AnimatedTypeHelpers.cs (6)

80return Math.Abs(to - from); 86Math.Pow(GetSegmentLengthDouble(from.Left, to.Left), 2.0) 87+ Math.Pow(GetSegmentLengthDouble(from.Top, to.Top), 2.0) 88+ Math.Pow(GetSegmentLengthDouble(from.Right, to.Right), 2.0) 89+ Math.Pow(GetSegmentLengthDouble(from.Bottom, to.Bottom), 2.0); 91return Math.Sqrt(totalLength);

MS\Internal\Annotations\Component\MarkedHighlightComponent.cs (1)

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

MS\Internal\AppModel\IconHelper.cs (1)

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

MS\Internal\Controls\InkCanvasInnerCanvas.cs (4)

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

MS\Internal\Controls\StickyNote\StickyNoteAnnotations.cs (6)

1046if (DoubleUtil.GreaterThan(Math.Abs(offsetX), Math.Abs(_offsetX))) 1052offset = Math.Max(offset, -(rectStickyNote.Left - rectPage.Left)); 1058if (DoubleUtil.GreaterThan(Math.Abs(offsetY), Math.Abs(_offsetY))) 1063offset = Math.Max(offset, -(rectStickyNote.Top - rectPage.Top));

MS\Internal\Data\RBTree.cs (1)

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

MS\Internal\Documents\ContentElementCollection.cs (1)

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

MS\Internal\Documents\DocumentGrid.cs (18)

315if (Math.Abs(pageNumber - _firstVisiblePageNumber) > 1) 576double clippedHorizontalOffset = Math.Min(_horizontalOffset, ExtentWidth - ViewportWidth); 577clippedHorizontalOffset = Math.Max(clippedHorizontalOffset, 0.0); 619double clippedVerticalOffset = Math.Min(_verticalOffset, ExtentHeight - ViewportHeight); 620clippedVerticalOffset = Math.Max(clippedVerticalOffset, 0.0); 1213pageOffset = new Point(Math.Max(ViewportWidth, ExtentWidth) - (xOffset + pageSize.Width), yOffset); 1443visiblePages.Add(_childrenCollection[_firstPageVisualIndex + j - Math.Max(0, firstPage)]); 1597double centerWidth = Math.Max(ViewportWidth, ExtentWidth); 2218(int)Math.Floor(ViewportWidth / 2223maxColumns = Math.Min(maxColumns, _pageCache.PageCount); 2224maxColumns = Math.Min(maxColumns, DocumentViewerConstants.MaximumMaxPagesAcross); 2235int rows = (int)Math.Floor((double)(_pageCache.PageCount / columns)); 2247double aspectDiff = Math.Abs(layoutAspect - viewportAspect); 2356newScale = Math.Max(newScale, CurrentMinimumScale); 2357newScale = Math.Min(newScale, DocumentViewerConstants.MaximumScale); 2426scaleFactor = Math.Min(compensatedViewportWidth / rowWidth, compensatedViewportHeight / rowHeight); 2455scaleFactor = Math.Min(compensatedViewportWidth / rowWidth, 2681Math.Max(0.0, (ExtentWidth - row.RowSize.Width) / 2.0) : 0.0;

MS\Internal\Documents\DocumentPageTextView.cs (2)

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

MS\Internal\Documents\FlowDocumentView.cs (8)

81desiredSize.Width = Math.Min(constraint.Width, _formatter.DocumentPage.Size.Width); 82desiredSize.Height = Math.Min(constraint.Height, _formatter.DocumentPage.Size.Height); 131if (Math.Abs(_scrollData.ExtentWidth - _scrollData.ViewportWidth) < 1) 135if (Math.Abs(_scrollData.ExtentHeight - _scrollData.ViewportHeight) < 1) 141Math.Max(0, Math.Min(_scrollData.ExtentWidth - _scrollData.ViewportWidth, _scrollData.HorizontalOffset)), 142Math.Max(0, Math.Min(_scrollData.ExtentHeight - _scrollData.ViewportHeight, _scrollData.VerticalOffset)));

MS\Internal\Documents\IFlowDocumentViewer.cs (2)

818GoToPage(Math.Max(1, MasterPageNumber - 2)); 826GoToPage(Math.Min(PageCount, MasterPageNumber + 2));

MS\Internal\Documents\MultiPageTextView.cs (17)

759Invariant.Assert(Math.Abs(request.NewCount) >= Math.Abs(linesMoved)); 831Invariant.Assert(Math.Abs(request.NewCount) >= Math.Abs(pagesMoved)); 979Invariant.Assert(Math.Abs(pagesMoved) <= Math.Abs(count)); 1097horz = Math.Min(Math.Abs(point.X - textViewBounds.Left), Math.Abs(point.X - textViewBounds.Right)); 1105vert = Math.Min(Math.Abs(point.Y - textViewBounds.Top), Math.Abs(point.Y - textViewBounds.Bottom)); 1107textViewProximities[i] = Math.Sqrt(Math.Pow(horz, 2) + Math.Pow(vert, 2)); 1192int closestDistance = Math.Abs(count); 1217int distance = Math.Abs(currentPageNumber - pageNumber);

MS\Internal\Documents\RowCache.cs (13)

310double roundedOffset = Math.Round(offset, _findOffsetPrecision); 318double rowOffset = Math.Round(_rowCache[i].VerticalOffset, _findOffsetPrecision); 319double rowHeight = Math.Round(_rowCache[i].RowSize.Height, _findOffsetPrecision); 410startOffset = Math.Round(startOffset, _findOffsetPrecision); 411endOffset = Math.Round(endOffset, _findOffsetPrecision); 417double rowOffset = Math.Round(_rowCache[i].VerticalOffset, _findOffsetPrecision); 469_extentWidth = Math.Max(currentRow.RowSize.Width, _extentWidth); 536_layoutColumns = Math.Min(_layoutColumns, PageCache.PageCount); 537_layoutColumns = Math.Max(1, _layoutColumns); 651pivotPage = Math.Max(0, PageCache.PageCount - columns); 979_extentWidth = Math.Max(newRow.RowSize.Width, _extentWidth); 1109_extentWidth = Math.Max(row.RowSize.Width, _extentWidth); 1379_rowSize.Height = Math.Max(pageSize.Height, _rowSize.Height);

MS\Internal\Documents\ScrollData.cs (4)

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

MS\Internal\Documents\TextBoxLine.cs (1)

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

MS\Internal\Documents\TextBoxView.cs (32)

452desiredSize.Width = Math.Min(constraint.Width, desiredSize.Width); 453desiredSize.Height = Math.Min(constraint.Height, desiredSize.Height); 646int startOffset = Math.Min(_lineMetrics[_lineMetrics.Count - 1].EndOffset, startPosition.Offset); 647int endOffset = Math.Min(_lineMetrics[_lineMetrics.Count - 1].EndOffset, endPosition.Offset); 654firstLineIndex = Math.Max(firstLineIndex, GetLineIndexFromOffset(startOffset, LogicalDirection.Forward)); 655lastLineIndex = Math.Min(lastLineIndex, GetLineIndexFromOffset(endOffset, LogicalDirection.Backward)); 724int nextLineIndex = Math.Max(0, Math.Min(_lineMetrics.Count - 1, lineIndex + count)); 1742Math.Max(0, Math.Min(_scrollData.ExtentWidth - _scrollData.ViewportWidth, _scrollData.HorizontalOffset)), 1743Math.Max(0, Math.Min(_scrollData.ExtentHeight - _scrollData.ViewportHeight, _scrollData.VerticalOffset))); 1889int endOffset = Math.Min(range.StartIndex + range.PositionsAdded, _host.TextContainer.SymbolCount); 2000int startOffset = Math.Max(_lineMetrics[lineIndex].Offset, unclippedStartOffset); 2001int endOffset = Math.Min(_lineMetrics[lineIndex].EndOffset, unclippedEndOffset); 2096int startOffset = Math.Max(lineStartOffset, unclippedStartOffset); 2097int endOffset = Math.Min(lineEndOffset, unclippedEndOffset); 2156lastLineIndex = (int)Math.Ceiling((viewport.Y + viewport.Height) / _lineHeight) - 1; 2159firstLineIndex = Math.Max(0, Math.Min(firstLineIndex, _lineMetrics.Count - 1)); 2160lastLineIndex = Math.Max(0, Math.Min(lastLineIndex, _lineMetrics.Count - 1)); 2232desiredSize.Width = Math.Max(desiredSize.Width, line.Width); 2506int lastCoveredCharOffset = range.StartIndex + Math.Max(range.PositionsAdded, range.PositionsRemoved); 2602desiredSize.Width = Math.Max(desiredSize.Width, _lineMetrics[i].Width); 2665int lineIndex = Math.Max(oldLineVisualsIndex, firstLineIndex); 2666int lineCount = Math.Min(oldLastLineIndex, firstLineIndex + count - 1) - lineIndex + 1; 2751count = Math.Max(0, count); 2757count = Math.Min(count, _viewportLineVisuals.Count - start); 2932int rangeStart = Math.Max(viewportStart, selectionStart); 2933int rangeSize = Math.Min(viewportEnd, selectionEnd) - rangeStart; 3069padding = Math.Max(0, viewport.Height - _contentSize.Height);

MS\Internal\Documents\TextContainerHelper.cs (6)

198_cpFirst = Math.Min(_cpFirst, cpFirst); 199_cpLast = Math.Max(_cpLast, cpLast); 223_ranges[i * 2] = Math.Min(_ranges[i * 2], cpFirst); 224_ranges[i * 2 + 1] = Math.Max(_ranges[i * 2 + 1], cpLast); 246_ranges[pos * 2 + 1] = Math.Max(_ranges[pos * 2 + 1], _ranges[(pos + 1) * 2 + 1]); 471int depth = Math.Min(ancestorsStart.Count, ancestorsEnd.Count);

MS\Internal\Documents\TextDocumentView.cs (2)

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

MS\Internal\Documents\TextParagraphView.cs (6)

160lineIndex = Math.Max(0, lineIndex + count); 161lineIndex = Math.Min(lines.Count - 1, lineIndex); 571lineIndex = Math.Max(Math.Min((int)(point.Y / approximatedLineHeight), lines.Count - 1), 0); 717siblingGap = Math.Max(lineBox.X - (siblingLineBox.X + siblingLineBox.Width), 0); 746siblingGap = Math.Max(siblingLineBox.X - (lineBox.X + lineBox.Width), 0);

MS\Internal\Globalization\LocalizableResourceBuilder.cs (2)

575Readability readability = (Readability)Math.Min( 581Modifiability modifiability = (Modifiability)Math.Min(

MS\Internal\Helper.cs (7)

1065headerSize.Height = Math.Max(itemsCorrectionFactor.Top, headerSize.Height); 1069headerSize.Height = Math.Max(virtualizingElement.DesiredSize.Height, headerSize.Height); 1071headerSize.Width = Math.Max(virtualizingElement.DesiredSize.Width, headerSize.Width); 1102itemPixelSize.Width = Math.Max(desiredSize.Width, itemPixelSize.Width); 1115itemPixelSizeBeforeViewport.Width = Math.Max(desiredSize.Width, itemPixelSizeBeforeViewport.Width); 1127itemPixelSizeInViewport.Width = Math.Max(desiredSize.Width, itemPixelSizeInViewport.Width); 1138itemPixelSizeAfterViewport.Width = Math.Max(desiredSize.Width, itemPixelSizeAfterViewport.Width);

MS\Internal\Ink\LassoHelper.cs (6)

108double step = Math.Sqrt(MinDistanceSquared / distanceSquared); 228&& DoubleUtil.GreaterThanOrClose(point.X, Math.Min(prevLassoPoint.X, lassoPoint.X)) 229&& DoubleUtil.LessThanOrClose(point.X, Math.Max(prevLassoPoint.X, lassoPoint.X))) 238if (DoubleUtil.GreaterThanOrClose(point.X, Math.Max(prevLassoPoint.X, lassoPoint.X))) 244if ((0 == i) && DoubleUtil.AreClose(point.X, Math.Max(prevLassoPoint.X, lassoPoint.X))) 249else if (DoubleUtil.GreaterThanOrClose(point.X, Math.Min(prevLassoPoint.X, lassoPoint.X)))

MS\Internal\Ink\PenCursorManager.cs (3)

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

MS\Internal\PtsHost\CellParagraph.cs (1)

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

MS\Internal\PtsHost\ContainerParaClient.cs (2)

60_rect.du = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.du); 61_rect.dv = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.dv);

MS\Internal\PtsHost\ContainerParagraph.cs (13)

504fsrcToFillSubtrack.u = Math.Max(Math.Min(fsrcToFillSubtrack.u, fsrcToFill.u + fsrcToFill.du - 1), fsrcToFill.u); 505fsrcToFillSubtrack.du = Math.Max(fsrcToFillSubtrack.du, 0); 518fsrcToFillSubtrack.v = Math.Max(Math.Min(fsrcToFillSubtrack.v, fsrcToFill.v + fsrcToFill.dv - 1), fsrcToFill.v); 519fsrcToFillSubtrack.dv = Math.Max(fsrcToFillSubtrack.dv, 0); 579dvrUsed = Math.Min(fsrcToFill.dv, dvrUsed); 662urSubtrack = Math.Max(Math.Min(urTrack + mbp.MBPLeft, urTrack + durTrack - 1), urTrack); 663durSubtrack = Math.Max(durTrack - (mbp.MBPLeft + mbp.MBPRight), 0); 792urSubtrack = Math.Max(Math.Min(urTrack + mbp.MBPLeft, urTrack + durTrack - 1), urTrack); 793durSubtrack = Math.Max(durTrack - (mbp.MBPLeft + mbp.MBPRight), 0);

MS\Internal\PtsHost\DtrList.cs (2)

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

MS\Internal\PtsHost\FigureHelper.cs (5)

174value = Math.Max(1, Math.Min(value, structuralCache.CurrentFormatContext.PageHeight)); 179value = Math.Max(1, Math.Min(value, structuralCache.CurrentFormatContext.PageHeight - pageMargin.Top - pageMargin.Bottom)); 247width = Math.Min(width, pageWidth);

MS\Internal\PtsHost\FigureParaClient.cs (4)

74_contentRect.du = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.du - mbp.BPRight - mbp.BPLeft); 76_contentRect.dv = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.dv - mbp.BPBottom - mbp.BPTop); 79_paddingRect.du = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.du - mbp.BorderRight - mbp.BorderLeft); 81_paddingRect.dv = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.dv - mbp.BorderBottom - mbp.BorderTop);

MS\Internal\PtsHost\FigureParagraph.cs (4)

149int subpageWidth = Math.Max(1, TextDpi.ToTextDpi(anchorLimitedWidth) - (mbp.BPLeft + mbp.BPRight)); 158int subpageHeight = Math.Max(1, TextDpi.ToTextDpi(anchorLimitedHeight) - (mbp.BPTop + mbp.BPBottom)); 601width = Math.Max(TextDpi.MinWidth, maxTotalWidth - elementMarginWidth); 630height = Math.Max(TextDpi.MinWidth, maxTotalHeight - elementMarginHeight);

MS\Internal\PtsHost\FloaterParaClient.cs (4)

197_contentRect.du = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.du - mbp.BPRight - mbp.BPLeft); 199_contentRect.dv = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.dv - mbp.BPBottom - mbp.BPTop); 202_paddingRect.du = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.du - mbp.BorderRight - mbp.BorderLeft); 204_paddingRect.dv = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.dv - mbp.BorderBottom - mbp.BorderTop);

MS\Internal\PtsHost\FloaterParagraph.cs (7)

208dvrAvailable = Math.Min(dvrAvailable, PTS.dvBottomUndefined / 2); 214dvrAvailable = Math.Min(dvrAvailable, TextDpi.ToTextDpi(StructuralCache.CurrentFormatContext.PageHeight)); 227subpageHeight = Math.Max(1, dvrAvailable - (mbp.MBPTop + mbp.MBPBottom)); 658subpageWidth = Math.Max(1, durSpecified - (mbp.BPLeft + mbp.BPRight)); 663subpageWidth = Math.Max(1, durAvailable - (mbp.MBPLeft + mbp.MBPRight)); 669subpageWidth = Math.Max(1, durAvailable - (mbp.MBPLeft + mbp.MBPRight)); 872return Math.Min(desiredSize, spaceAvailable);

MS\Internal\PtsHost\Line.cs (1)

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

MS\Internal\PtsHost\ListMarkerSourceInfo.cs (1)

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

MS\Internal\PtsHost\MarginCollapsingState.cs (2)

163_maxPositive = Math.Max(_maxPositive, mcs._maxPositive); 164_minNegative = Math.Min(_minNegative, mcs._minNegative);

MS\Internal\PtsHost\PtsHelper.cs (9)

832return Math.Max(1, Math.Min(PTS.Restrictions.tscColumnRestriction-1, columns)); // at least 1 column is required 879columnWidth = Math.Max(1, Math.Min(columnWidth, pageWidth)); 881freeSpace = Math.Max(0, freeSpace); 922pfscolinfo[i].durBefore = Math.Max(0, pfscolinfo[i].durBefore); 923pfscolinfo[i].durWidth = Math.Max(1, pfscolinfo[i].durWidth); 954pfscolinfo[i].durBefore = Math.Max(0, pfscolinfo[i].durBefore); 955pfscolinfo[i].durWidth = Math.Max(1, pfscolinfo[i].durWidth);

MS\Internal\PtsHost\PtsHost.cs (1)

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

MS\Internal\PtsHost\PtsPage.cs (7)

768rect.dv = Math.Max(rect.dv, bbox.fsrc.dv); 771_calculatedSize.Width = Math.Max(TextDpi.MinWidth, TextDpi.FromTextDpi(rect.du)); 772_calculatedSize.Height = Math.Max(TextDpi.MinWidth, TextDpi.FromTextDpi(rect.dv)); 776_contentSize.Width = Math.Max(Math.Max(TextDpi.FromTextDpi(bbox.fsrc.du), TextDpi.MinWidth), _calculatedSize.Width); 777_contentSize.Height = Math.Max(TextDpi.MinWidth, TextDpi.FromTextDpi(bbox.fsrc.dv)); 783_contentSize.Height = Math.Max(_contentSize.Height, _calculatedSize.Height);

MS\Internal\PtsHost\SubpageParaClient.cs (4)

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

MS\Internal\PtsHost\SubpageParagraph.cs (16)

166subpageWidth = Math.Max(1, subpageWidth - (mbp.MBPLeft + mbp.MBPRight)); 175subpageHeight = Math.Max(1, subpageHeight - (marginTop + mbp.BPTop)); 229dvrUsed = Math.Max(dvrUsed, fsbbox.fsrc.dv + fsbbox.fsrc.v); 230fsrcToFill.du = Math.Max(fsrcToFill.du, fsbbox.fsrc.du + fsbbox.fsrc.u); 273fsbbox.fsrc.du = Math.Max(fsrcToFill.du - (mbp.MarginLeft + mbp.MarginRight), 0); 274fsbbox.fsrc.dv = Math.Max(dvrUsed - dvrTopSpace, 0); 353subpageWidth = Math.Max(1, subpageWidth - (mbp.MBPLeft + mbp.MBPRight)); 425dvrUsed = Math.Max(dvrUsed, fsbbox.fsrc.dv + fsbbox.fsrc.v); 426durTrack = Math.Max(durTrack, fsbbox.fsrc.du + fsbbox.fsrc.u); 436fsbbox.fsrc.du = Math.Max(durTrack - (mbp.MarginLeft + mbp.MarginRight), 0); 437fsbbox.fsrc.dv = Math.Max(dvrUsed - dvrTopSpace, 0); 513subpageWidth = Math.Max(1, subpageWidth - (mbp.MBPLeft + mbp.MBPRight)); 584dvrUsed = Math.Max(dvrUsed, fsbbox.fsrc.dv + fsbbox.fsrc.v); 585durTrack = Math.Max(durTrack, fsbbox.fsrc.du + fsbbox.fsrc.u); 595fsbbox.fsrc.du = Math.Max(durTrack - (mbp.MarginLeft + mbp.MarginRight), 0); 596fsbbox.fsrc.dv = Math.Max(dvrUsed - dvrTopSpace, 0);

MS\Internal\PtsHost\TableParaClient.cs (11)

645int du = Math.Min(Math.Abs(rect.u - u), Math.Abs(rect.u + rect.du - u)); 646int dv = Math.Min(Math.Abs(rect.v - v), Math.Abs(rect.v + rect.dv - v)); 994int iDistance = Math.Abs((cpc.Rect.u + cpc.Rect.du / 2) - suggestedU); 1070int iDistance = Math.Abs((cpc.Rect.u + cpc.Rect.du / 2) - suggestedU); 1927Math.Min(_calculatedColumns.Length, columns)); 2419Math.Max(_rect.du - (mbpInfo.BPRight + mbpInfo.BPLeft), 1), 2420Math.Max(_rect.dv - calculatedBPBottom - calculatedBPTop, 1)

MS\Internal\PtsHost\TextParaClient.cs (19)

738int dcpStart = Math.Max(cpStartTextPointer, cpParagraphStart) - cpParagraphStart; 742int dcpEnd = Math.Min(cpEndTextPointer, cpParagraphEnd) - cpParagraphStart; 1407int countVisualsShiftBeforeChange = Math.Min(Math.Max(lineIndexToBeginRemoval - _lineIndexFirstVisual, 0), lineVisuals.Count); 1424int actualLinesToRemove = Math.Min(Math.Max(lineIndexToBeginRemoval - _lineIndexFirstVisual + cLinesToRemove, 0), lineVisuals.Count); 1452int actualLinesToRemove = Math.Min(cLinesToRemove, lineVisuals.Count - (lineIndexToBeginRemoval - _lineIndexFirstVisual)); 1872int dcpRangeStartForThisLine = Math.Max(lineDesc.dcpFirst, dcpStart); 1875int cchRangeForThisLine = Math.Max(Math.Min(lineDesc.dcpLim, dcpEnd) - dcpRangeStartForThisLine, 1); 1982int dcpRangeStartForThisElem = Math.Max(elemDesc.dcpFirst, dcpStart); 1985int cchRangeForThisElem = Math.Max(Math.Min(elemDesc.dcpLim, dcpEnd) - dcpRangeStartForThisElem, 1); 2077lineRect.Width = Math.Max(lineVisual.WidthIncludingTrailingWhitespace, 0); 2188elementRect.Width = Math.Max(lineVisual.WidthIncludingTrailingWhitespace, 0); 3126line.GetGlyphRuns(glyphRuns, Math.Max(dcpStart, lineDesc.dcpFirst), Math.Min(dcpEnd, lineDesc.dcpLim)); 3188line.GetGlyphRuns(glyphRuns, Math.Max(dcpStart, element.dcpFirst), Math.Min(dcpEnd, element.dcpLim));

MS\Internal\PtsHost\TextParagraph.cs (2)

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

MS\Internal\PtsHost\UIElementParaClient.cs (2)

75_rect.du = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.du); 76_rect.dv = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.dv);

MS\Internal\PtsHost\UIElementParagraph.cs (3)

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)); 430elementHeight = Math.Max(TextDpi.FromTextDpi(1), elementHeight);

MS\Internal\Text\ComplexLine.cs (1)

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

MS\Internal\Text\DynamicPropertyReader.cs (2)

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

MS\Internal\Text\LineProperties.cs (2)

182lineAdvance = Math.Max(lineAdvance, _lineHeight); 214lineAdvance = Math.Max(lineAdvance, _lineHeight);

MS\Internal\Text\SimpleLine.cs (1)

80Math.Min(dcp, _content.Length)

MS\Internal\Text\TextDpi.cs (3)

50return (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);;

MS\Internal\WindowsRuntime\Generated\WinRT\Projections\IReadOnlyList.cs (1)

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

System\Windows\Application.cs (1)

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

System\Windows\Automation\Peers\CalendarAutomationPeer.cs (1)

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

System\Windows\Automation\Peers\ScrollViewerAutomationPeer.cs (3)

208return Math.Min(100.0, (double)(owner.ViewportWidth * 100.0 / owner.ExtentWidth)); 222return Math.Min(100.0, (double)(owner.ViewportHeight * 100.0 / owner.ExtentHeight)); 258return Math.Min(100.0, (double)(viewport * 100.0 / extent));

System\Windows\Controls\Border.cs (12)

System\Windows\Controls\ColumnDefinition.cs (1)

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

System\Windows\Controls\DataGrid.cs (18)

2623indexToSelect = Math.Min(Items.Count - numSelected - 1, indexToSelect); 5025int newRowCount = Math.Abs(endIndex - startIndex) + 1; 5026int newColumnCount = Math.Abs(endColumnIndex - startColumnIndex) + 1; 5044int previousStartIndex = Math.Min(startIndex, currentCellIndex); 5045int previousRowCount = Math.Abs(currentCellIndex - startIndex) + 1; 5046int previousStartColumnIndex = Math.Min(startColumnIndex, currentCellColumnIndex); 5047int previousColumnCount = Math.Abs(currentCellColumnIndex - startColumnIndex) + 1; 5087_selectedCells.AddRegion(Math.Min(startIndex, endIndex), Math.Min(startColumnIndex, endColumnIndex), newRowCount, newColumnCount); 5685nextDisplayIndex = Math.Max(0, InternalColumns.LastVisibleDisplayIndex); 5766nextRowIndex = Math.Max(0, Items.Count - 1); 5951index = Math.Max(0, Math.Min(numItems - 1, index + (shiftModifier ? -1 : 1))); 6091int jumpDistance = Math.Max(1, (int)scrollHost.ViewportHeight - 1); 6093targetIndex = Math.Max(0, Math.Min(targetIndex, Items.Count - 1)); 6536distance = Math.Abs(pt.Y - cellBounds.Top); 6544distance = Math.Abs(pt.X - cellBounds.Left);

System\Windows\Controls\DataGridCellsPanel.cs (6)

184measureHeight = Math.Max(measureHeight, blockMeasureSize.Height); 396measureSize.Height = Math.Max(measureSize.Height, childSize.Height); 416measureSize.Height = Math.Max(measureSize.Height, headerSize.Height); 611measureHeight = Math.Max(measureHeight, childSize.Height); 1892childMeasureWidth = Math.Max(averageColumnWidth, column.MinWidth); 1893childMeasureWidth = Math.Min(childMeasureWidth, column.MaxWidth);

System\Windows\Controls\DataGridColumnCollection.cs (24)

748int columnCount = Math.Min(newFrozenCount, Count); 756int columnCount = Math.Min(oldFrozenCount, Count); 946availableStarSpace = Math.Max(0.0, availableStarSpace - columnMinWidth); 1227double displayValue = Math.Max(width.DesiredValue, minWidth); 1267double displayValue = Math.Min(width.DesiredValue, maxWidth); 1335TakeAwayWidthFromColumns(null, Math.Abs(availableSpaceChange), false, newTotalAvailableSpace); 1359column.SetWidthInternal(new DataGridLength(width.Value, width.UnitType, width.DesiredValue, Math.Min(width.DesiredValue, maxWidth))); 1381Math.Max(width.DisplayValue - nonRetrievableSpace, changedColumn.MinWidth))); 1453return Math.Max(availableSpace - requiredSpace, 0.0); 1664column.UpdateWidthForStarColumn(Math.Max(columnDesiredWidth, column.MinWidth), columnDesiredWidth, columnDesiredWidth / perStarWidth); 1693double columnExcessWidth = onlyShrinkToDesiredWidth ? width.DisplayValue - Math.Max(width.DesiredValue, column.MinWidth) : width.DisplayValue - column.MinWidth; 1778double maxColumnResizeWidth = expandBeyondDesiredWidth ? column.MaxWidth : Math.Min(width.DesiredValue, column.MaxWidth); 1913column.UpdateWidthForStarColumn(Math.Min(columnDesiredWidth, column.MaxWidth), columnDesiredWidth, columnDesiredWidth / perStarWidth); 2000double usedStarSpace = ComputeStarColumnWidths(Math.Min(expectedStarSpace, sumOfStarMaxWidths)); 2001giveAwayWidth = Math.Max(usedStarSpace - expectedStarSpace, 0.0); 2071double lagWidth = Math.Min(width.DesiredValue, columnMaxWidth) - width.DisplayValue; 2102if (DoubleUtil.LessThan(width.DisplayValue, Math.Min(width.DesiredValue, column.MaxWidth))) 2130giveAwayWidth -= Math.Min(contributingSpace, giveAwayWidth); 2137giveAwayWidth = Math.Min(giveAwayWidth, Math.Max(0d, totalSpace - usedSpace)); 2184return Math.Min(usedSpace - totalAvailableWidth, takeAwayWidth); 2192takeAwayWidth = Math.Max(0.0, takeAwayWidth - unusedSpace); 2263double usedStarSpace = ComputeStarColumnWidths(Math.Max(expectedStarSpace, sumOfStarMinWidths)); 2264takeAwayWidth = Math.Max(usedStarSpace - expectedStarSpace, 0.0);

System\Windows\Controls\DataGridHelper.cs (4)

32return new Size(size.Width, Math.Max(0.0, size.Height - thickness)); 36return new Size(Math.Max(0.0, size.Width - thickness), size.Height); 715value = Math.Max(value, minValue); 716value = Math.Min(value, maxValue);

System\Windows\Controls\DataGridRow.cs (1)

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

System\Windows\Controls\DefinitionBase.cs (2)

125_minSize = Math.Max(_minSize, minSize); 875sharedMinSize = Math.Max(sharedMinSize, _registry[i]._minSize);

System\Windows\Controls\DockPanel.cs (10)

216childConstraint = new Size(Math.Max(0.0, constraint.Width - accumulatedWidth), 217Math.Max(0.0, constraint.Height - accumulatedHeight)); 237parentHeight = Math.Max(parentHeight, accumulatedHeight + childDesiredSize.Height); 243parentWidth = Math.Max(parentWidth, accumulatedWidth + childDesiredSize.Width); 250parentWidth = Math.Max(parentWidth, accumulatedWidth); 251parentHeight = Math.Max(parentHeight, accumulatedHeight); 281Math.Max(0.0, arrangeSize.Width - (accumulatedLeft + accumulatedRight)), 282Math.Max(0.0, arrangeSize.Height - (accumulatedTop + accumulatedBottom)) ); 295rcChild.X = Math.Max(0.0, arrangeSize.Width - accumulatedRight); 306rcChild.Y = Math.Max(0.0, arrangeSize.Height - accumulatedBottom);

System\Windows\Controls\DocumentViewer.cs (2)

1338VerticalOffset = Math.Max(verticalOffset, 0.0); 1339HorizontalOffset = Math.Max(horizontalOffset, 0.0);

System\Windows\Controls\FlowDocumentReader.cs (2)

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

System\Windows\Controls\FlowDocumentScrollViewer.cs (8)

584Math.Max(ia.OriginWidth, pagePadding.Left), 585Math.Max(ia.OriginHeight, pagePadding.Top), 586Math.Max(ia.MediaSizeWidth - (ia.OriginWidth + ia.ExtentWidth), pagePadding.Right), 587Math.Max(ia.MediaSizeHeight - (ia.OriginHeight + ia.ExtentHeight), pagePadding.Bottom)); 623Zoom = Math.Min(Zoom + ZoomIncrement, MaxZoom); 635Zoom = Math.Max(Zoom - ZoomIncrement, MinZoom); 701SetCurrentValueInternal(ZoomProperty, Math.Min(Zoom + ZoomIncrement, MaxZoom)); 705SetCurrentValueInternal(ZoomProperty, Math.Max(Zoom - ZoomIncrement, MinZoom));

System\Windows\Controls\Grid.cs (69)

368gridDesiredSize.Width = Math.Max(gridDesiredSize.Width, child.DesiredSize.Width); 369gridDesiredSize.Height = Math.Max(gridDesiredSize.Height, child.DesiredSize.Height); 899ColumnIndex = Math.Min(GetColumn(child), DefinitionsU.Length - 1), 902RowIndex = Math.Min(GetRow(child), DefinitionsV.Length - 1) 908cell.ColumnSpan = Math.Min(GetColumnSpan(child), DefinitionsU.Length - cell.ColumnIndex); 912cell.RowSpan = Math.Min(GetRowSpan(child), DefinitionsV.Length - cell.RowIndex); 1089userMinSize = Math.Max(userMinSize, Math.Min(userSize, userMaxSize)); 1113definitions[i].MeasureSize = Math.Max(userMinSize, Math.Min(userSize, userMaxSize)); 1213DefinitionsU[PrivateCells[i].ColumnIndex].UpdateMinSize(Math.Min(children[i].DesiredSize.Width, DefinitionsU[PrivateCells[i].ColumnIndex].UserMaxSize)); 1230DefinitionsV[PrivateCells[i].RowIndex].UpdateMinSize(Math.Min(children[i].DesiredSize.Height, DefinitionsV[PrivateCells[i].RowIndex].UserMaxSize)); 1451double maxSize = Math.Max(definitions[i].UserMaxSize, minSize); 1503double newMinSize = Math.Min(sizeToDistribute / (count - i), tempDefinitions[i].PreferredSize); 1533tempDefinitions[i].UpdateMinSize(Math.Min(newMinSize, tempDefinitions[i].SizeCache)); 1544tempDefinitions[i].UpdateMinSize(Math.Min(newMinSize, tempDefinitions[i].SizeCache)); 1655starValue = Math.Min(starValue, c_starClip); 1659double maxSize = Math.Max(definitions[i].MinSize, definitions[i].UserMaxSize); 1660maxSize = Math.Min(maxSize, c_starClip); 1698double userSize = Math.Max(availableSize - takenSize, 0.0) * (starValue / tempDefinitions[i].SizeCache); 1699resolvedSize = Math.Min(userSize, tempDefinitions[i].UserMaxSize); 1700resolvedSize = Math.Max(tempDefinitions[i].MinSize, resolvedSize); 1761double power = Math.Floor(Math.Log(Double.MaxValue / maxStar / starCount, 2.0)); 1764scale = Math.Pow(2.0, power - 4.0); // -4 is just for paranoia 1812double effectiveMaxSize = Math.Max(def.MinSize, def.UserMaxSize); 1884resolvedSize = Math.Max(resolvedDef.MinSize, resolvedDef.UserMaxSize); 2002double resolvedSize = (def.MeasureSize > 0.0) ? Math.Max(availableSize - takenSize, 0.0) * (def.MeasureSize / def.SizeCache) : 0.0; 2005resolvedSize = Math.Min(resolvedSize, def.UserMaxSize); 2006resolvedSize = Math.Max(def.MinSize, resolvedSize); 2095starValue = Math.Min(starValue, c_starClip); 2099double maxSize = Math.Max(definitions[i].MinSizeForArrange, definitions[i].UserMaxSize); 2100maxSize = Math.Min(maxSize, c_starClip); 2140definitions[i].SizeCache = Math.Max(definitions[i].MinSizeForArrange, Math.Min(userSize, userMaxSize)); 2185double userSize = Math.Max(finalSize - allPreferredArrangeSize, 0.0) * (starValue / definitions[definitionIndices[i]].SizeCache); 2186resolvedSize = Math.Min(userSize, definitions[definitionIndices[i]].UserMaxSize); 2187resolvedSize = Math.Max(definitions[definitionIndices[i]].MinSizeForArrange, resolvedSize); 2212final = Math.Max(final, definitions[definitionIndex].MinSizeForArrange); 2213final = Math.Min(final, definitions[definitionIndex].SizeCache); 2219final = Math.Max(final, definitions[definitionIndex].MinSizeForArrange); 2220final = Math.Min(final, definitions[definitionIndex].SizeCache); 2253final = Math.Max(final, definition.MinSizeForArrange); 2269final = Math.Max(final, definition.MinSizeForArrange); 2340double power = Math.Floor(Math.Log(Double.MaxValue / maxStar / starCount, 2.0)); 2343scale = Math.Pow(2.0, power - 4.0); // -4 is just for paranoia 2387double effectiveMaxSize = Math.Max(def.MinSizeForArrange, def.UserMaxSize); 2426def.SizeCache = Math.Max(def.MinSizeForArrange, Math.Min(userSize, userMaxSize)); 2495resolvedSize = Math.Max(resolvedDef.MinSizeForArrange, resolvedDef.UserMaxSize); 2627double resolvedSize = (def.MeasureSize > 0.0) ? Math.Max(finalSize - takenSize, 0.0) * (def.MeasureSize / def.SizeCache) : 0.0; 2630resolvedSize = Math.Min(resolvedSize, def.UserMaxSize); 2631resolvedSize = Math.Max(def.MinSizeForArrange, resolvedSize); 2722final = Math.Max(final, definition.MinSizeForArrange); 2738final = Math.Max(final, definition.MinSizeForArrange); 2780double minPower = Math.Floor(Math.Log(minRatio, 2.0)); 2781double maxPower = Math.Floor(Math.Log(maxRatio, 2.0)); 2782double f = Math.Pow(2.0, Math.Floor((minPower + maxPower) / 2.0)); 2861Array.Clear(extData.TempDefinitions, 0, Math.Max(DefinitionsU.Length, DefinitionsV.Length)); 3066int requiredLength = Math.Max(DefinitionsU.Length, DefinitionsV.Length) * 2; 3099int requiredLength = Math.Max(Math.Max(DefinitionsU.Length, DefinitionsV.Length), 1) * 2; 3117int requiredLength = Math.Max(DefinitionsU.Length, DefinitionsV.Length); 3209return (Math.Abs(d) < c_epsilon); 3220return (Math.Abs(d1 - d2) < c_epsilon);

System\Windows\Controls\GridSplitter.cs (13)

503_resizeData.SplitterLength = Math.Min(ActualWidth, ActualHeight); 655horizontalChange = Math.Round(horizontalChange / dragIncrement) * dragIncrement; 656verticalChange = Math.Round(verticalChange / dragIncrement) * dragIncrement; 663_resizeData.Adorner.OffsetX = Math.Min(Math.Max(horizontalChange, _resizeData.MinChange), _resizeData.MaxChange); 667_resizeData.Adorner.OffsetY = Math.Min(Math.Max(verticalChange, _resizeData.MinChange), _resizeData.MaxChange); 801definition1Min = Math.Max(definition1Min, _resizeData.SplitterLength); 805definition2Min = Math.Max(definition2Min, _resizeData.SplitterLength); 811minDelta = -Math.Min(definition1Len - definition1Min, definition2Max - definition2Len); 812maxDelta = Math.Min(definition1Max - definition1Len, definition2Len - definition2Min); 920delta = Math.Min(Math.Max(delta, min), max);

System\Windows\Controls\GridViewHeaderRowPresenter.cs (8)

258double childConstraintWidth = Math.Max(0.0, constraint.Width - accumulatedWidth); 280childConstraintWidth = Math.Min(childConstraintWidth, column.DesiredWidth); 288childConstraintWidth = Math.Min(childConstraintWidth, column.Width); 295maxHeight = Math.Max(maxHeight, child.DesiredSize.Height); 302maxHeight = Math.Max(maxHeight, _paddingHeader.DesiredSize.Height); 351double childArrangeWidth = Math.Min(remainingWidth, ((column.State == ColumnMeasureState.SpecificWidth) ? column.Width : column.DesiredWidth)); 385rect = new Rect(accumulatedWidth, 0.0, Math.Max(remainingWidth, 0.0), arrangeSize.Height); 1245return (DoubleUtil.GreaterThan(Math.Abs(currentPos.X - originalPos.X), c_thresholdX));

System\Windows\Controls\GridViewRowPresenter.cs (5)

143double childConstraintWidth = Math.Max(0.0, constraint.Width - accumulatedWidth); 172childConstraintWidth = Math.Min(childConstraintWidth, column.DesiredWidth); 180childConstraintWidth = Math.Min(childConstraintWidth, column.Width); 187maxHeight = Math.Max(maxHeight, child.DesiredSize.Height); 220double childArrangeWidth = Math.Min(remainingWidth, ((column.State == ColumnMeasureState.SpecificWidth) ? column.Width : column.DesiredWidth));

System\Windows\Controls\InkPresenter.cs (4)

169newSize.Width = Math.Max(newSize.Width, sizeStrokes.Width); 170newSize.Height = Math.Max(newSize.Height, sizeStrokes.Height); 203availableSize = new Size(Math.Min(arrangeSize.Width, _constraintSize.Width), 204Math.Min(arrangeSize.Height, _constraintSize.Height));

System\Windows\Controls\ItemContainerGenerator.cs (1)

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

System\Windows\Controls\ItemsControl.cs (2)

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

System\Windows\Controls\MenuScrollingVisibilityConverter.cs (2)

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

System\Windows\Controls\PasswordTextNavigator.cs (2)

195finalCount = Math.Min(count, _container.SymbolCount - _offset); 199finalCount = Math.Min(count, _offset);

System\Windows\Controls\PopupControlService.cs (2)

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

System\Windows\Controls\Primitives\BulletDecorator.cs (5)

251contentConstraint.Width = Math.Max(0.0, contentConstraint.Width - bulletSize.Width); 257Size desiredSize = new Size(bulletSize.Width + contentSize.Width, Math.Max(bulletSize.Height, contentSize.Height)); 293contentSize.Width = Math.Max(content.DesiredSize.Width, arrangeSize.Width - bullet.DesiredSize.Width); 294contentSize.Height = Math.Max(content.DesiredSize.Height, arrangeSize.Height); 299bulletOffsetY += Math.Max(0d, centerY - bulletSize.Height * 0.5d);

System\Windows\Controls\Primitives\DataGridCellsPresenter.cs (1)

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

System\Windows\Controls\Primitives\DataGridColumnHeadersPresenter.cs (10)

116desiredSize.Width = Math.Max(desiredSize.Width, indicatorSize.Width); 117desiredSize.Height = Math.Max(desiredSize.Height, indicatorSize.Height); 124desiredSize.Width = Math.Max(desiredSize.Width, indicatorSize.Width); 125desiredSize.Height = Math.Max(desiredSize.Height, indicatorSize.Height); 128desiredSize.Width = Math.Min(availableSize.Width, desiredSize.Width); 148childRect.Width = Math.Max(finalSize.Width, dataGrid.CellsPanelActualWidth); 631return DoubleUtil.GreaterThan(Math.Abs(currentPos.X - originalPos.X), SystemParameters.MinimumHorizontalDragDistance); 680height = Math.Max(_draggingSrcColumnHeader.RenderSize.Height, _columnHeaderDragIndicator.Height); 902columnEstimatedWidth = Math.Max(averageColumnWidth, column.MinWidth); 903columnEstimatedWidth = Math.Min(columnEstimatedWidth, column.MaxWidth);

System\Windows\Controls\Primitives\DocumentPageView.cs (2)

952pageVisualRect.Width = Math.Min(pageVisualRect.Width, maxWidth); 953pageVisualRect.Height = Math.Min(pageVisualRect.Height, maxHeight);

System\Windows\Controls\Primitives\Popup.cs (26)

2114if (Math.Abs(score - childArea) < Tolerance) 2140if (Math.Abs(intersection.Width - childBounds.Width) > Tolerance || 2141Math.Abs(intersection.Height - childBounds.Height) > Tolerance) 2155if (!IsTransparent || double.IsNaN(horizontalAxis.Y) || Math.Abs(horizontalAxis.Y) < Tolerance) 2167else if (IsTransparent && Math.Abs(horizontalAxis.X) < Tolerance) 2190if (!IsTransparent || double.IsNaN(verticalAxis.X) || Math.Abs(verticalAxis.X) < Tolerance) 2201else if (IsTransparent && Math.Abs(verticalAxis.Y) < Tolerance) 2256if (!IsTransparent || double.IsNaN(verticalAxis.X) || Math.Abs(verticalAxis.X) < Tolerance) 2258limitSize.Height = Math.Max(0.0, Math.Max(screenBounds.Bottom - targetBounds.Bottom, targetBounds.Top - screenBounds.Top)); 2260else if (IsTransparent && Math.Abs(verticalAxis.Y) < Tolerance) 2262limitSize.Width = Math.Max(0.0, Math.Max(screenBounds.Right - targetBounds.Right, targetBounds.Left - screenBounds.Left)); 2278if (!IsTransparent || double.IsNaN(horizontalAxis.X) || Math.Abs(horizontalAxis.Y) < Tolerance) 2280limitSize.Width = Math.Max(0.0, Math.Max(screenBounds.Right - targetBounds.Right, targetBounds.Left - screenBounds.Left)); 2282else if (IsTransparent && Math.Abs(horizontalAxis.X) < Tolerance) 2284limitSize.Height = Math.Max(0.0, Math.Max(screenBounds.Bottom - targetBounds.Bottom, targetBounds.Top - screenBounds.Top)); 2634desiredSize.Width = Math.Min(desiredSize.Width, screenBounds.Width); 2635desiredSize.Width = Math.Min(desiredSize.Width, limitSize.Width); 2639desiredSize.Height = Math.Min(desiredSize.Height, screenBounds.Height); 2640desiredSize.Height = Math.Min(desiredSize.Height, maxHeight); 2641desiredSize.Height = Math.Min(desiredSize.Height, limitSize.Height); 2714return new Rect(mousePoint.x, mousePoint.y - 1, Math.Max(0, cursorWidth - hotX), Math.Max(0, cursorHeight - hotY + 2));

System\Windows\Controls\Primitives\PopupRoot.cs (4)

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

System\Windows\Controls\Primitives\ScrollBar.cs (8)

332perpendicularDragDelta = Math.Abs(verticalDragDelta); 336perpendicularDragDelta = Math.Abs(horizontalDragDelta); 408newValue = Math.Min(Math.Max(newValue, Minimum), Maximum); 540double newValue = Math.Max(Value - SmallChange, Minimum); 549double newValue = Math.Min(Value + SmallChange, Maximum); 558double newValue = Math.Max(Value - LargeChange, Minimum); 567double newValue = Math.Min(Value + LargeChange, Maximum);

System\Windows\Controls\Primitives\ScrollContentPresenter.cs (5)

434desiredSize.Width = Math.Min(constraint.Width, desiredSize.Width); 435desiredSize.Height = Math.Min(constraint.Height, desiredSize.Height); 483childRect.Width = Math.Max(childRect.Width, arrangeSize.Width); 484childRect.Height = Math.Max(childRect.Height, arrangeSize.Height); 681return Math.Max(0.0, offset);

System\Windows\Controls\Primitives\TabPanel.cs (5)

204Height = Math.Max(0d, element.DesiredSize.Height - margin.Top - margin.Bottom), 205Width = Math.Max(0d, element.DesiredSize.Width - margin.Left - margin.Right) 277childSize.Height = Math.Max(0d, childSize.Height - topOffset - bottomOffset); 278childSize.Width = Math.Max(0d, childSize.Width - leftOffset - rightOffset); 409currentAverageGap = Math.Max(0d, (rowWidthLimit - currentRowWidth) / numberOfHeadersInCurrentRow); // The amout of width that should be added to justify the header

System\Windows\Controls\Primitives\TickBar.cs (4)

520Point pt2 = new Point(startPoint.X + tickLen2, y0 + Math.Abs(tickLen2) * progression); 533pt2 = new Point(startPoint.X + tickLen2, y0 - Math.Abs(tickLen2) * progression); 625Point pt2 = new Point(x0 + Math.Abs(tickLen2) * progression, startPoint.Y + tickLen2); 638pt2 = new Point(x0 - Math.Abs(tickLen2) * progression, startPoint.Y + tickLen2);

System\Windows\Controls\Primitives\ToolBarOverflowPanel.cs (7)

111_wrapWidth = Math.Min(_wrapWidth, constraint.Width); 120_panelSize.Width = Math.Max(curLineSize.Width, _panelSize.Width); 126_panelSize.Width = Math.Max(sz.Width, _panelSize.Width); 134curLineSize.Height = Math.Max(sz.Height, curLineSize.Height); 139_panelSize.Width = Math.Max(curLineSize.Width, _panelSize.Width); 155_wrapWidth = Math.Min(_wrapWidth, arrangeBounds.Width); 175curLineSize.Height = Math.Max(sz.Height, curLineSize.Height);

System\Windows\Controls\Primitives\ToolBarPanel.cs (6)

115panelDesiredSize.Height = Math.Max(panelDesiredSize.Height, childDesiredSize.Height); 119panelDesiredSize.Width = Math.Max(panelDesiredSize.Width, childDesiredSize.Width); 174panelDesiredSize.Height = Math.Max(panelDesiredSize.Height, childDesiredSize.Height); 179panelDesiredSize.Width = Math.Max(panelDesiredSize.Width, childDesiredSize.Width); 300rcChild.Height = Math.Max(arrangeSize.Height, child.DesiredSize.Height); 307rcChild.Width = Math.Max(arrangeSize.Width, child.DesiredSize.Width);

System\Windows\Controls\Primitives\Track.cs (11)

70return Math.Max(Minimum, Math.Min(Maximum, val)); 462double viewportSize = Math.Max(0.0, ViewportSize); 555double range = Math.Max(0.0, Maximum - min); 556double offset = Math.Min(range, Value - min); 594double range = Math.Max(0.0, Maximum - min); 595double offset = Math.Min(range, Value - min); 599double extent = Math.Max(0.0, range) + viewportSize; 611thumbMinLength = Math.Floor(buttonHeight * 0.5); 619thumbMinLength = Math.Floor(buttonWidth * 0.5); 625thumbLength = Math.Max(thumbMinLength, thumbLength);

System\Windows\Controls\Primitives\UniformGrid.cs (1)

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

System\Windows\Controls\PrintDialog.cs (6)

297MinPage = Math.Max(1, Math.Min(_minPage, _maxPage)) 299dlg.MaxPage = Math.Max(dlg.MinPage, Math.Max(_minPage, _maxPage)); 305Math.Max((int)dlg.MinPage, _pageRange.PageFrom), 306Math.Min((int)dlg.MaxPage, _pageRange.PageTo));

System\Windows\Controls\RowDefinition.cs (1)

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

System\Windows\Controls\ScrollViewer.cs (17)

400get { return Math.Max(0.0, ExtentWidth - ViewportWidth); } 408get { return Math.Max(0.0, ExtentHeight - ViewportHeight); } 1745DoubleUtil.LessThan(Math.Abs(unusedX), PanningInfo.PreFeedbackTranslationX)) 1753DoubleUtil.LessThan(Math.Abs(unusedY), PanningInfo.PreFeedbackTranslationY)) 1798double newUnused = Math.Max(unused + delta, 0); 1807double newUnused = Math.Min(unused + delta, 0); 1818Math.Round(PanningRatio * cumulativeTranslation / _panningInfo.DeltaPerHorizontalOffet)); 1828Math.Round(PanningRatio * cumulativeTranslation / _panningInfo.DeltaPerVerticalOffset)); 1841if (Math.Abs(Environment.TickCount - _panningInfo.InertiaBoundaryBeginTimestamp) < PanningInfo.InertiaBoundryMinimumTicks) 1846return (DoubleUtil.GreaterThanOrClose(Math.Abs(_panningInfo.UnusedTranslation.X), PanningInfo.MaxInertiaBoundaryTranslation) || 1847DoubleUtil.GreaterThanOrClose(Math.Abs(_panningInfo.UnusedTranslation.Y), PanningInfo.MaxInertiaBoundaryTranslation)); 1866bool validX = (DoubleUtil.GreaterThan(Math.Abs(translation.X), PanningInfo.PrePanTranslation)); 1867bool validY = (DoubleUtil.GreaterThan(Math.Abs(translation.Y), PanningInfo.PrePanTranslation)); 1877bool biggerX = (DoubleUtil.GreaterThanOrClose(Math.Abs(translation.X), Math.Abs(translation.Y))); 1890bool biggerY = (DoubleUtil.GreaterThanOrClose(Math.Abs(translation.Y), Math.Abs(translation.X)));

System\Windows\Controls\SinglePageViewer.cs (6)

702Math.Max(ia.OriginWidth, pagePadding.Left), 703Math.Max(ia.OriginHeight, pagePadding.Top), 704Math.Max(ia.MediaSizeWidth - (ia.OriginWidth + ia.ExtentWidth), pagePadding.Right), 705Math.Max(ia.MediaSizeHeight - (ia.OriginHeight + ia.ExtentHeight), pagePadding.Bottom)); 743SetCurrentValueInternal(ZoomProperty, Math.Min(Zoom + ZoomIncrement, MaxZoom)); 755SetCurrentValueInternal(ZoomProperty, Math.Max(Zoom - ZoomIncrement, MinZoom));

System\Windows\Controls\Slider.cs (15)

987valueToSize = Math.Max(0.0, (trackSize.Width - thumbSize.Width) / range); 993Canvas.SetLeft(rangeElement, (thumbSize.Width * 0.5) + Math.Max(Maximum - SelectionEnd, 0) * valueToSize); 997Canvas.SetLeft(rangeElement, (thumbSize.Width * 0.5) + Math.Max(SelectionStart - Minimum, 0) * valueToSize); 1009valueToSize = Math.Max(0.0, (trackSize.Height - thumbSize.Height) / range); 1015Canvas.SetTop(rangeElement, (thumbSize.Height * 0.5) + Math.Max(SelectionStart - Minimum, 0) * valueToSize); 1019Canvas.SetTop(rangeElement, (thumbSize.Height * 0.5) + Math.Max(Maximum - SelectionEnd,0) * valueToSize); 1052valueToSize = Math.Max(0.0, (trackSize.Width - thumbSize.Width) / range); 1076valueToSize = Math.Max(0.0, (trackSize.Height - thumbSize.Height) / range); 1184previous = Minimum + (Math.Round(((value - Minimum) / TickFrequency)) * TickFrequency); 1185next = Math.Min(Maximum, previous + TickFrequency); 1205double next = SnapToTick(Math.Max(this.Minimum, Math.Min(this.Maximum, value + direction))); 1243double tickNumber = Math.Round((value - Minimum) / TickFrequency); 1401this.SetCurrentValueInternal(ValueProperty, Math.Max(this.Minimum, Math.Min(this.Maximum, snappedValue)));

System\Windows\Controls\Stack.cs (15)

593stackDesiredSize.Height = Math.Max(stackDesiredSize.Height, childDesiredSize.Height); 598stackDesiredSize.Width = Math.Max(stackDesiredSize.Width, childDesiredSize.Width); 658offset.Y = Math.Max(0, Math.Min(offset.Y, extent.Height - viewport.Height)); 666offset.X = Math.Max(0, Math.Min(offset.X, extent.Width - viewport.Width)); 671stackDesiredSize.Width = Math.Min(stackDesiredSize.Width, constraint.Width); 672stackDesiredSize.Height = Math.Min(stackDesiredSize.Height, constraint.Height); 750rcChild.Height = Math.Max(arrangeSize.Height, child.DesiredSize.Height); 757rcChild.Width = Math.Max(arrangeSize.Width, child.DesiredSize.Width); 891double left = Math.Max(targetRectOffset, minPhysicalOffset); 892targetRectSize = Math.Max(Math.Min(targetRectSize + targetRectOffset, minPhysicalOffset + viewportSize) - left, 0); 990iNewOffset = Math.Max(Math.Min(numberOfItems - 1, iNewOffset), 0);

System\Windows\Controls\StickyNote.cs (4)

1111horizontalChange = Math.Min(Math.Max(minBoundary.X, horizontalChange), maxBoundary.X); 1112verticalChange = Math.Min(Math.Max(minBoundary.Y, verticalChange), maxBoundary.Y);

System\Windows\Controls\TextBlock.cs (12)

1259Size contentSize = new Size(Math.Max(0.0, constraint.Width - (padding.Left + padding.Right)), 1260Math.Max(0.0, constraint.Height - (padding.Top + padding.Bottom))); 1299desiredSize.Width = Math.Max(desiredSize.Width, line.GetCollapsedWidth()); 1522double contentBottom = Math.Max(0.0, RenderSize.Height - Padding.Bottom); 1956Size contentSize = new Size(Math.Max(0.0, _referenceSize.Width - (padding.Left + padding.Right)), 1957Math.Max(0.0, _referenceSize.Height - (padding.Top + padding.Bottom))); 2309int dcpStart = Math.Max(dcpLineStart, dcpPositionStart); 2310int dcpEnd = Math.Min(dcpLineEnd, dcpPositionEnd); 3096Size contentSize = new Size(Math.Max(0.0, computedSize.Width - (padding.Left + padding.Right)), 3097Math.Max(0.0, computedSize.Height - (padding.Top + padding.Bottom))); 3146double contentBottom = Math.Max(0.0, RenderSize.Height - Padding.Bottom); 3176width = Math.Max(0.0, width - paddingWidth);

System\Windows\Controls\TextBox.cs (3)

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

System\Windows\Controls\TextRangeAdaptor.cs (1)

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

System\Windows\Controls\ToolBar.cs (2)

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

System\Windows\Controls\ToolBarTray.cs (5)

380bandThickness = Math.Max(bandThickness, fHorizontal ? toolBar.DesiredSize.Height : toolBar.DesiredSize.Width); 395toolBarTrayDesiredSize.Width = Math.Max(toolBarTrayDesiredSize.Width, bandLength); 400toolBarTrayDesiredSize.Height = Math.Max(toolBarTrayDesiredSize.Height, bandLength); 788currentToolBar.Width = Math.Max(currentToolBar.MinLength, currentToolBar.RenderSize.Width - toolBarOffset + position); 790currentToolBar.Height = Math.Max(currentToolBar.MinLength, currentToolBar.RenderSize.Height - toolBarOffset + position);

System\Windows\Controls\VirtualizedCellInfoCollection.cs (12)

608int left = Math.Max(Left, region.Left); 609int top = Math.Max(Top, region.Top); 610int right = Math.Min(Right, region.Right); 611int bottom = Math.Min(Bottom, region.Bottom); 681Left = Math.Min(Left, region.Left); 682Top = Math.Min(Top, region.Top); 683Right = Math.Max(prevRight, region.Right); 684Bottom = Math.Max(prevBottom, region.Bottom); 724int top = Math.Max(Top, region.Top); 725int bottom = Math.Min(Bottom, region.Bottom); 732int top = Math.Max(Top, region.Top); 733int bottom = Math.Min(Bottom, region.Bottom);

System\Windows\Controls\VirtualizingStackPanel.cs (185)

System\Windows\Controls\WrapPanel.cs (5)

242panelSize.U = Math.Max(curLineSize.U, panelSize.U); 248panelSize.U = Math.Max(sz.U, panelSize.U); 256curLineSize.V = Math.Max(sz.V, curLineSize.V); 261panelSize.U = Math.Max(curLineSize.U, panelSize.U); 316curLineSize.V = Math.Max(sz.V, curLineSize.V);

System\Windows\Documents\Block.cs (2)

486double maxLineHeight = Math.Min(1000000, PTS.MaxFontSize); 530double maxThickness = Math.Min(1000000, PTS.MaxPageSize);

System\windows\Documents\CaretElement.cs (6)

405deltaToScroll = Math.Abs(targetPoint.Y); 406scroller.ScrollToVerticalOffset(Math.Max(0, scroller.VerticalOffset - deltaToScroll - scrollerHeight / 4)); 412scroller.ScrollToVerticalOffset(Math.Min(scroller.ExtentHeight, scroller.VerticalOffset + deltaToScroll + scrollerHeight / 4)); 422deltaToScroll = Math.Abs(targetPoint.X); 423scroller.ScrollToHorizontalOffset(Math.Max(0, scroller.HorizontalOffset - deltaToScroll - scrollerWidth / 4)); 429scroller.ScrollToHorizontalOffset(Math.Min(scroller.ExtentWidth, scroller.HorizontalOffset + deltaToScroll + scrollerWidth / 4));

System\Windows\Documents\DocumentSequenceTextPointer.cs (1)

1029distance = Math.Abs(distance);

System\Windows\Documents\Figure.cs (1)

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

System\Windows\Documents\FixedPageStructure.cs (4)

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

System\Windows\Documents\FixedSOMPageConstructor.cs (5)

554if (Math.Abs(textRunRect.Left - fixedBlockRect.Left) <= textRun.DefaultCharWidth || 555Math.Abs(textRunRect.Right - fixedBlockRect.Right) <= textRun.DefaultCharWidth) 1027if (Math.Abs(t.BoundingRect.Left - row.BoundingRect.Left) < fudge && 1028Math.Abs(t.BoundingRect.Right - row.BoundingRect.Right) < fudge && 1029Math.Abs(t.BoundingRect.Bottom - row.BoundingRect.Top) < fudge)

System\Windows\Documents\FixedSOMSemanticBox.cs (1)

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

System\Windows\Documents\FixedSOMTextRun.cs (2)

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

System\Windows\Documents\FixedTextBuilder.cs (2)

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

System\Windows\Documents\FixedTextView.cs (2)

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

System\Windows\Documents\Floater.cs (1)

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

System\Windows\Documents\FlowDocument.cs (5)

1516double maxSize = Math.Min(1000000, PTS.MaxPageSize); 1531double maxSize = Math.Min(1000000, PTS.MaxPageSize); 1546double maxSize = Math.Min(1000000, PTS.MaxPageSize); 1567double maxRuleWidth = Math.Min(1000000, PTS.MaxPageSize); 1578double maxGap = Math.Min(1000000, PTS.MaxPageSize);

System\Windows\Documents\FlowPosition.cs (2)

213maxLength = Math.Min(maxLength, remainingLength); 310distance = Math.Abs(distance);

System\Windows\Documents\Glyphs.cs (3)

142Math.Max(0, designRect.Right), 143Math.Max(0, designRect.Bottom) 519estimatedNumberOfGlyphs = Math.Max(estimatedNumberOfGlyphs, glyphsProp.Length / 5);

System\Windows\Documents\ImmComposition.cs (5)

650milPointTopLeft = new Point(Math.Min(rectStart.Left, rectEnd.Left), Math.Min(rectStart.Top, rectEnd.Top)); 651milPointBottomRight = new Point(Math.Max(rectStart.Left, rectEnd.Left), Math.Max(rectStart.Bottom, rectEnd.Bottom)); 1106_caretOffset = Math.Min(_caretOffset, text.Length);

System\Windows\Documents\List.cs (1)

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

System\Windows\Documents\Paragraph.cs (1)

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

System\Windows\Documents\RangeContentEnumerator.cs (1)

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

System\Windows\Documents\Speller.cs (7)

994int timeOutOffset = Math.Min(data.TextMap.ContentEndOffset, sentenceEndOffset); 1178sTextRange = (SpellerInteropBase.ITextRange)segments[Math.Max(i, 0)]; 1181contextOffset = Math.Min(sTextRange.Start, contentOffset); 1186sTextRange = (SpellerInteropBase.ITextRange)segments[Math.Min(i, segments.Count-1)]; 1189contextOffset = Math.Max(sTextRange.Start + sTextRange.Length, contentOffset); 1685runCount = Math.Min(runCount, _text.Length - _textLength); 1686runCount = Math.Min(runCount, position.GetOffsetToPosition(contextEnd));

System\Windows\Documents\Table.cs (2)

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

System\Windows\Documents\TableColumn.cs (1)

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

System\Windows\Documents\TableRowGroup.cs (1)

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

System\Windows\Documents\TextContainerChangedEventArgs.cs (3)

238change.RemovedLength += Math.Max(0, length - change.AddedLength); 239change.AddedLength = Math.Max(0, change.AddedLength - length); 401int cancelledCount = Math.Min(overlap, newChange.RemovedLength);

System\windows\Documents\TextEditor.cs (2)

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

System\Windows\Documents\TextElement.cs (1)

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

System\Windows\Documents\TextFindEngine.cs (4)

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

System\Windows\Documents\TextPointer.cs (1)

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

System\Windows\Documents\TextPointerBase.cs (5)

101maxCount = Math.Min(count, thisPointer.GetOffsetToPosition(limit)); 105maxCount = Math.Min(count, limit.GetOffsetToPosition(thisPointer)); 107maxCount = Math.Min(count, maxCount); 1423runLength = Math.Min(navigator.GetTextRunLength(LogicalDirection.Backward), SelectionWordBreaker.MinContextLength - preceedingCount); 1442runLength = Math.Min(navigator.GetTextRunLength(LogicalDirection.Forward), SelectionWordBreaker.MinContextLength - followingCount);

System\Windows\Documents\TextRangeEdit.cs (4)

2345new DoublePropertyRange (Paragraph.TextIndentProperty, -Math.Min(1000000, PTS.MaxPageSize), Math.Min(1000000, PTS.MaxPageSize)) 2367double retValue = Math.Max(_lowerBound, value); 2368retValue = Math.Min(retValue, _upperBound);

System\Windows\Documents\TextRangeEditTables.cs (10)

332int firstRowIndex = Math.Min(anchorCell.Row.Index, movingCell.Row.Index); 333int lastRowIndex = Math.Max(anchorCell.Row.Index + anchorCell.RowSpan - 1, movingCell.Row.Index + movingCell.RowSpan - 1); 334int firstColumnIndex = Math.Min(anchorCell.ColumnIndex, movingCell.ColumnIndex); 335int lastColumnIndex = Math.Max(anchorCell.ColumnIndex + anchorCell.ColumnSpan - 1, movingCell.ColumnIndex + movingCell.ColumnSpan - 1); 1429int cCols = Math.Abs(columnCount); 1711_dxr = Math.Max(_dxr, 0.0); 1734xPosAdorner = Math.Max(xPosAdorner, _columnRect.Left - this.LeftDragMax); 1735xPosAdorner = Math.Min(xPosAdorner, _columnRect.Right + this.RightDragMax); 1746dx = Math.Max(dx, - this.LeftDragMax); 1747dx = Math.Min(dx, this.RightDragMax);

System\windows\Documents\TextSelection.cs (2)

2232caretRectangle.Y += caretRectangle.Height - Math.Abs(bottom.Y - top.Y); 2233caretRectangle.Height = Math.Abs(bottom.Y - top.Y);

System\Windows\Documents\TextStore.cs (12)

985milPointTopLeft = new Point(Math.Min(rectPrev.Left, rectCur.Left), Math.Min(rectPrev.Top, rectCur.Top)); 986milPointBottomRight = new Point(Math.Max(rectPrev.Left, rectCur.Left), Math.Max(rectPrev.Bottom, rectCur.Bottom)); 2443runCount = TextPointerBase.GetTextWithLimit(navigator, LogicalDirection.Forward, text, charsCopied, Math.Min(cchReq, text.Length - charsCopied), limit); 2846double radSin = Math.Asin(tf.M12 / Math.Sqrt((tf.M11 * tf.M11) + (tf.M12 * tf.M12))); 2847double radCos = Math.Acos(tf.M11 / Math.Sqrt((tf.M11 * tf.M11) + (tf.M12 * tf.M12))); 2849double angleCos = Math.Round((radCos * 180) / Math.PI, 0); 3809int extraCharsAllowed = Math.Max(0, this.TextEditor.MaxLength - currentLength);

System\Windows\Documents\TextTreeText.cs (4)

101firstCount = Math.Min(count, firstBlock.Count - firstBlockLocalOffset); 298count = Math.Min(rightBlock.FreeCapacity, length - textOffset); 340count = Math.Min(neighborBlock.FreeCapacity, textEndOffset - textOffset); 354count = Math.Min(rightBlock.FreeCapacity, textEndOffset - textOffset);

System\Windows\Documents\TextTreeTextBlock.cs (4)

93newText = new char[Math.Min(this.Count + count, MaxBlockSize)]; 108count = Math.Min(count, _gapSize); 247copyCount = Math.Min(count, _gapOffset - logicalOffset); 262copyCount = Math.Min(count, _text.Length - logicalOffset);

System\Windows\Documents\Tracing\SpellerCOMActionTraceLogger.cs (3)

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

System\Windows\Documents\WinRTSpellerInteropExtensions.cs (1)

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

System\Windows\Documents\XamlToRtfWriter.cs (2)

1730tableWidth = Math.Max(tableWidth, lastCellX); 2891formatState.FontSize = (long)Math.Round(fs);

System\Windows\FigureLength.cs (1)

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

System\Windows\FrameworkElement.cs (59)

4045maxHeight = Math.Max(Math.Min(height, maxHeight), minHeight); 4048minHeight = Math.Max(Math.Min(maxHeight, height), minHeight); 4055maxWidth = Math.Max(Math.Min(width, maxWidth), minWidth); 4058minWidth = Math.Max(Math.Min(maxWidth, width), minWidth); 4160Double yCoverD = (yConstrInfinite ? Double.PositiveInfinity : Math.Abs(yConstr/d)); 4161Double xCoverA = (xConstrInfinite ? Double.PositiveInfinity : Math.Abs(xConstr/a)); 4181h = Math.Min(0.5*Math.Abs(xConstr/c), yCoverD); 4192w = Math.Min( 0.5*Math.Abs(yConstr/b), xCoverA); 4200Double yCoverB = Math.Abs(yConstr/b); 4201Double xCoverC = Math.Abs(xConstr/c); 4221h = Math.Min(0.5*Math.Abs(yConstr/d), xCoverC); 4232w = Math.Min( 0.5*Math.Abs(xConstr/a), yCoverB); 4238Double xCoverA = Math.Abs(xConstr / a); // w-intercept of x-constraint line. 4239Double xCoverC = Math.Abs(xConstr / c); // h-intercept of x-constraint line. 4241Double yCoverB = Math.Abs(yConstr / b); // w-intercept of y-constraint line. 4242Double yCoverD = Math.Abs(yConstr / d); // h-intercept of y-constraint line. 4249w = Math.Min(yCoverB, xCoverA) * 0.5; 4250h = Math.Min(xCoverC, yCoverD) * 0.5; 4267Double expandFactor = Math.Min(xConstr / childBoundsTr.Width, 4326Math.Max(availableSize.Width - marginWidth, 0), 4327Math.Max(availableSize.Height - marginHeight, 0)); 4375frameworkAvailableSize.Width = Math.Max(mm.minWidth, Math.Min(frameworkAvailableSize.Width, mm.maxWidth)); 4376frameworkAvailableSize.Height = Math.Max(mm.minHeight, Math.Min(frameworkAvailableSize.Height, mm.maxHeight)); 4389Math.Max(desiredSize.Width, mm.minWidth), 4390Math.Max(desiredSize.Height, mm.minHeight)); 4454ltd?.TransformedUnroundedDS = new Size(Math.Max(0, clippedDesiredWidth), Math.Max(0, clippedDesiredHeight)); 4500return new Size(Math.Max(0, clippedDesiredWidth), Math.Max(0, clippedDesiredHeight)); 4562arrangeSize.Width = Math.Max(0, arrangeSize.Width - marginWidth); 4563arrangeSize.Height = Math.Max(0, arrangeSize.Height - marginHeight); 4572transformedUnroundedDS.Width = Math.Max(0, transformedUnroundedDS.Width - marginWidth); 4573transformedUnroundedDS.Height = Math.Max(0, transformedUnroundedDS.Height- marginHeight); 4582unclippedDesiredSize = new Size(Math.Max(0, this.DesiredSize.Width - marginWidth), 4583Math.Max(0, this.DesiredSize.Height - marginHeight)); 4588unclippedDesiredSize.Width = Math.Max(transformedUnroundedDS.Width, unclippedDesiredSize.Width); 4589unclippedDesiredSize.Height = Math.Max(transformedUnroundedDS.Height, unclippedDesiredSize.Height); 4676double effectiveMaxWidth = Math.Max(unclippedDesiredSize.Width, mm.maxWidth); 4683double effectiveMaxHeight = Math.Max(unclippedDesiredSize.Height, mm.maxHeight); 4714Size clippedInkSize = new Size(Math.Min(innerInkSize.Width, mm.maxWidth), 4715Math.Min(innerInkSize.Height, mm.maxHeight)); 4747Size clientSize = new Size(Math.Max(0, finalRect.Width - marginWidth), 4748Math.Max(0, finalRect.Height - marginHeight)); 4899inkSize.Width = Math.Min(inkSize.Width, mm.maxWidth); 4900inkSize.Height = Math.Min(inkSize.Height, mm.maxHeight); 4917Size clippingSize = new Size(Math.Max(0, layoutSlotSize.Width - marginWidth), 4918Math.Max(0, layoutSlotSize.Height - marginHeight)); 5236inkSize.Width = Math.Min(inkSize.Width, mm.maxWidth); 5237inkSize.Height = Math.Min(inkSize.Height, mm.maxHeight);

System\Windows\Input\KeyboardNavigation.cs (9)

2506rect.Height = Math.Min(Math.Max(before, 0.0d), rect.Height); 2510double height = Math.Min(Math.Max(after, 0.0d), rect.Height); 2526return Math.Sqrt(deltaX * deltaX + deltaY * deltaY); 2657startRange = Math.Min(startRange, _horizontalBaseline); 2658endRange = Math.Max(endRange, _horizontalBaseline); 2678startRange = Math.Min(startRange, _verticalBaseline); 2679endRange = Math.Max(endRange, _verticalBaseline);

System\Windows\Interop\HwndHost.cs (2)

696desiredSize.Width = Math.Min(_desiredSize.Width, constraint.Width); 697desiredSize.Height = Math.Min(_desiredSize.Height, constraint.Height);

System\Windows\Markup\Baml2006\SharedStream.cs (2)

148long end = Math.Min(_position + 1, _length); 173long end = Math.Min(_position + count, _length);

System\Windows\Markup\BamlRecordReader.cs (1)

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

System\Windows\Shapes\Ellipse.cs (4)

88width = Math.Min(width, height); 92width = Math.Max(width, height); 115Math.Max(0, finalSize.Width - penThickness), // Width 116Math.Max(0, finalSize.Height - penThickness)); // Height

System\Windows\Shapes\Rectangle.cs (4)

141width = Math.Min(width, height); 145width = Math.Max(width, height); 169Math.Max(0, finalSize.Width - penThickness), // Width 170Math.Max(0, finalSize.Height - penThickness)); // Height

System\Windows\Shapes\Shape.cs (6)

464return Math.Abs(StrokeThickness); 480thickness = Math.Abs(strokeThickness); 583xScale = Math.Max(availableSize.Width - strokeThickness, 0); 584yScale = Math.Max(availableSize.Height - strokeThickness, 0); 711return new Size(Math.Max(bounds.Right, 0), 712Math.Max(bounds.Bottom, 0));

System\Windows\Shell\TaskbarItemInfo.cs (2)

105progressValue = Math.Max(progressValue, 0); 106progressValue = Math.Min(1, progressValue);

System\Windows\Shell\WindowChromeWorker.cs (23)

System\Windows\Standard\NativeMethods.cs (4)

2019Left = Math.Min(rect1.Left, rect2.Left), 2020Top = Math.Min(rect1.Top, rect2.Top), 2021Right = Math.Max(rect1.Right, rect2.Right), 2022Bottom = Math.Max(rect1.Bottom, rect2.Bottom),

System\Windows\SystemFonts.cs (1)

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

System\Windows\Window.cs (30)

1813frameworkAvailableSize.Width = Math.Max(mm.minWidth, Math.Min(frameworkAvailableSize.Width, mm.maxWidth)); 1814frameworkAvailableSize.Height = Math.Max(mm.minHeight, Math.Min(frameworkAvailableSize.Height, mm.maxHeight)); 1821Math.Max(desiredSize.Width, mm.minWidth), 1822Math.Max(desiredSize.Height, mm.minHeight)); 1843arrangeBounds.Width = Math.Max(mm.minWidth, Math.Min(arrangeBounds.Width, mm.maxWidth)); 1844arrangeBounds.Height = Math.Max(mm.minHeight, Math.Min(arrangeBounds.Height, mm.maxHeight)); 1879Width = Math.Max(0.0, arrangeBounds.Width - frameSize.Width), 1880Height = Math.Max(0.0, arrangeBounds.Height - frameSize.Height) 3415Width = ((constraint.Width == Double.PositiveInfinity) ? Double.PositiveInfinity : Math.Max(0.0, (constraint.Width - frameSize.Width))), 3416Height = ((constraint.Height == Double.PositiveInfinity) ? Double.PositiveInfinity : Math.Max(0.0, (constraint.Height - frameSize.Height))) 3461maxWidthDeviceUnits = Math.Max(_trackMaxWidthDeviceUnits, _windowMaxWidthDeviceUnits); 3462maxHeightDeviceUnits = Math.Max(_trackMaxHeightDeviceUnits, _windowMaxHeightDeviceUnits); 3471mm.minWidth = Math.Max(this.MinWidth, minSizeLogicalUnits.X); 3476mm.maxWidth = Math.Min(MinWidth, maxSizeLogicalUnits.X); 3482mm.maxWidth = Math.Min(MaxWidth, maxSizeLogicalUnits.X); 3493mm.minHeight = Math.Max(this.MinHeight, minSizeLogicalUnits.Y); 3498mm.maxHeight = Math.Min(this.MinHeight, maxSizeLogicalUnits.Y); 3504mm.maxHeight = Math.Min(MaxHeight, maxSizeLogicalUnits.Y); 3855leftDeviceUnits = Math.Min(leftDeviceUnits, workAreaRectDeviceUnits.right - currentSizeDeviceUnits.Width); 3856leftDeviceUnits = Math.Max(leftDeviceUnits, workAreaRectDeviceUnits.left); 3857topDeviceUnits = Math.Min(topDeviceUnits, workAreaRectDeviceUnits.bottom - currentSizeDeviceUnits.Height); 3858topDeviceUnits = Math.Max(topDeviceUnits, workAreaRectDeviceUnits.top); 4717_windowMaxWidthDeviceUnits = Math.Max(_windowMaxWidthDeviceUnits, windowSize.X); 4718_windowMaxHeightDeviceUnits = Math.Max(_windowMaxHeightDeviceUnits, windowSize.Y); 7606return new Size(Math.Max(0.0, pt.X), Math.Max(0.0, pt.Y));

Microsoft\Windows\Themes\ButtonChrome.cs (4)

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

Microsoft\Windows\Themes\ListBoxChrome.cs (2)

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

Microsoft\Windows\Themes\ScrollChrome.cs (5)

473bounds.Width = Math.Max(0.0, bounds.Width - 1.0); 544double height = Math.Min(7.0, bounds.Height); 567double width = Math.Min(7.0, bounds.Width); 739double widthScale = Math.Min(glyphWidth, bounds.Width) / glyphWidth; 740double heightScale = Math.Min(glyphHeight, bounds.Height) / glyphHeight;

src\Microsoft.DotNet.Wpf\src\Themes\Shared\Microsoft\Windows\Themes\DataGridHeaderBorder.cs (5)

192childWidth = Math.Max(0.0, childWidth - padding.Left - padding.Right); 197childHeight = Math.Max(0.0, childHeight - padding.Top - padding.Bottom); 232double childWidth = Math.Max(0.0, arrangeSize.Width - padding.Left - padding.Right); 233double childHeight = Math.Max(0.0, arrangeSize.Height - padding.Top - padding.Bottom); 299return Math.Max(0.0, d);

src\Microsoft.DotNet.Wpf\src\Themes\Shared\Microsoft\Windows\Themes\SystemDropShadowChrome.cs (5)

111double maxRadius = Math.Min(centerWidth * 0.5, centerHeight * 0.5); 112cornerRadius.TopLeft = Math.Min(cornerRadius.TopLeft, maxRadius); 113cornerRadius.TopRight = Math.Min(cornerRadius.TopRight, maxRadius); 114cornerRadius.BottomLeft = Math.Min(cornerRadius.BottomLeft, maxRadius); 115cornerRadius.BottomRight = Math.Min(cornerRadius.BottomRight, maxRadius);

Microsoft\Windows\Themes\ButtonChrome.cs (4)

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

Microsoft\Windows\Themes\ListBoxChrome.cs (2)

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

Microsoft\Windows\Themes\ScrollChrome.cs (5)

473bounds.Width = Math.Max(0.0, bounds.Width - 1.0); 544double height = Math.Min(7.0, bounds.Height); 567double width = Math.Min(7.0, bounds.Width); 739double widthScale = Math.Min(glyphWidth, bounds.Width) / glyphWidth; 740double heightScale = Math.Min(glyphHeight, bounds.Height) / glyphHeight;

src\Microsoft.DotNet.Wpf\src\Themes\Shared\Microsoft\Windows\Themes\DataGridHeaderBorder.cs (5)

192childWidth = Math.Max(0.0, childWidth - padding.Left - padding.Right); 197childHeight = Math.Max(0.0, childHeight - padding.Top - padding.Bottom); 232double childWidth = Math.Max(0.0, arrangeSize.Width - padding.Left - padding.Right); 233double childHeight = Math.Max(0.0, arrangeSize.Height - padding.Top - padding.Bottom); 299return Math.Max(0.0, d);

src\Microsoft.DotNet.Wpf\src\Themes\Shared\Microsoft\Windows\Themes\SystemDropShadowChrome.cs (5)

111double maxRadius = Math.Min(centerWidth * 0.5, centerHeight * 0.5); 112cornerRadius.TopLeft = Math.Min(cornerRadius.TopLeft, maxRadius); 113cornerRadius.TopRight = Math.Min(cornerRadius.TopRight, maxRadius); 114cornerRadius.BottomLeft = Math.Min(cornerRadius.BottomLeft, maxRadius); 115cornerRadius.BottomRight = Math.Min(cornerRadius.BottomRight, maxRadius);

Microsoft\Windows\Themes\ScrollChrome.cs (2)

240double height = Math.Min(7.0, bounds.Height); 255double width = Math.Min(7.0, bounds.Width);

src\Microsoft.DotNet.Wpf\src\Themes\Shared\Microsoft\Windows\Themes\DataGridHeaderBorder.cs (5)

192childWidth = Math.Max(0.0, childWidth - padding.Left - padding.Right); 197childHeight = Math.Max(0.0, childHeight - padding.Top - padding.Bottom); 232double childWidth = Math.Max(0.0, arrangeSize.Width - padding.Left - padding.Right); 233double childHeight = Math.Max(0.0, arrangeSize.Height - padding.Top - padding.Bottom); 299return Math.Max(0.0, d);

src\Microsoft.DotNet.Wpf\src\Themes\Shared\Microsoft\Windows\Themes\ProgressBarBrushConverter.cs (2)

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

src\Microsoft.DotNet.Wpf\src\Themes\Shared\Microsoft\Windows\Themes\SystemDropShadowChrome.cs (5)

111double maxRadius = Math.Min(centerWidth * 0.5, centerHeight * 0.5); 112cornerRadius.TopLeft = Math.Min(cornerRadius.TopLeft, maxRadius); 113cornerRadius.TopRight = Math.Min(cornerRadius.TopRight, maxRadius); 114cornerRadius.BottomLeft = Math.Min(cornerRadius.BottomLeft, maxRadius); 115cornerRadius.BottomRight = Math.Min(cornerRadius.BottomRight, maxRadius);

Microsoft\Windows\Themes\ClassicBorderDecorator.cs (11)

235float min = Math.Min(rgbColor.Red, Math.Min(rgbColor.Green, rgbColor.Blue)); 236float max = Math.Max(rgbColor.Red, Math.Max(rgbColor.Green, rgbColor.Blue)); 268saturation = Math.Max(0.0f, Math.Min(saturation, 1.0f)); 323float hue = (float)((hlsColor.Hue - Math.Floor(hlsColor.Hue)) * 6); 601Math.Max(0.0, rt.Width - thick.Left - thick.Right), 602Math.Max(0.0, rt.Height - thick.Top - thick.Bottom)); 690desired = new Size(Math.Min(borderSize.Width, availableSize.Width), Math.Min(borderSize.Height, availableSize.Height));

src\Microsoft.DotNet.Wpf\src\Themes\Shared\Microsoft\Windows\Themes\DataGridHeaderBorder.cs (5)

192childWidth = Math.Max(0.0, childWidth - padding.Left - padding.Right); 197childHeight = Math.Max(0.0, childHeight - padding.Top - padding.Bottom); 232double childWidth = Math.Max(0.0, arrangeSize.Width - padding.Left - padding.Right); 233double childHeight = Math.Max(0.0, arrangeSize.Height - padding.Top - padding.Bottom); 299return Math.Max(0.0, d);

src\Microsoft.DotNet.Wpf\src\Themes\Shared\Microsoft\Windows\Themes\ProgressBarBrushConverter.cs (2)

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

src\Microsoft.DotNet.Wpf\src\Themes\Shared\Microsoft\Windows\Themes\SystemDropShadowChrome.cs (5)

111double maxRadius = Math.Min(centerWidth * 0.5, centerHeight * 0.5); 112cornerRadius.TopLeft = Math.Min(cornerRadius.TopLeft, maxRadius); 113cornerRadius.TopRight = Math.Min(cornerRadius.TopRight, maxRadius); 114cornerRadius.BottomLeft = Math.Min(cornerRadius.BottomLeft, maxRadius); 115cornerRadius.BottomRight = Math.Min(cornerRadius.BottomRight, maxRadius);

Microsoft\Windows\Themes\ButtonChrome.cs (4)

345desired = new Size(Math.Min(sideThickness2, availableSize.Width), Math.Min(sideThickness2, availableSize.Height)); 363Width = Math.Max(0d, finalSize.Width - sideThickness2), 364Height = Math.Max(0d, finalSize.Height - sideThickness2)

Microsoft\Windows\Themes\ScrollChrome.cs (5)

305bounds.Width = Math.Max(0.0, bounds.Width - 1.0); 379double height = Math.Min(6.0, bounds.Height); 401double width = Math.Min(6.0, bounds.Width); 591double widthScale = Math.Min(glyphWidth, bounds.Width) / glyphWidth; 592double heightScale = Math.Min(glyphHeight, bounds.Height) / glyphHeight;

src\Microsoft.DotNet.Wpf\src\Themes\Shared\Microsoft\Windows\Themes\BulletChrome.cs (6)

187desired = new Size(Math.Min(11.0 + borderX, availableSize.Width), Math.Min(11.0 + borderY, availableSize.Height)); 210Math.Max(0, bounds.Width - thickness.Left - thickness.Right), 211Math.Max(0, bounds.Height - thickness.Top - thickness.Bottom)); 452Math.Max(0.0, rt.Width - thick.Left - thick.Right), 453Math.Max(0.0, rt.Height - thick.Top - thick.Bottom));

src\Microsoft.DotNet.Wpf\src\Themes\Shared\Microsoft\Windows\Themes\DataGridHeaderBorder.cs (5)

192childWidth = Math.Max(0.0, childWidth - padding.Left - padding.Right); 197childHeight = Math.Max(0.0, childHeight - padding.Top - padding.Bottom); 232double childWidth = Math.Max(0.0, arrangeSize.Width - padding.Left - padding.Right); 233double childHeight = Math.Max(0.0, arrangeSize.Height - padding.Top - padding.Bottom); 299return Math.Max(0.0, d);

src\Microsoft.DotNet.Wpf\src\Themes\Shared\Microsoft\Windows\Themes\ProgressBarBrushConverter.cs (2)

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

src\Microsoft.DotNet.Wpf\src\Themes\Shared\Microsoft\Windows\Themes\SystemDropShadowChrome.cs (5)

111double maxRadius = Math.Min(centerWidth * 0.5, centerHeight * 0.5); 112cornerRadius.TopLeft = Math.Min(cornerRadius.TopLeft, maxRadius); 113cornerRadius.TopRight = Math.Min(cornerRadius.TopRight, maxRadius); 114cornerRadius.BottomLeft = Math.Min(cornerRadius.BottomLeft, maxRadius); 115cornerRadius.BottomRight = Math.Min(cornerRadius.BottomRight, maxRadius);

Microsoft\Windows\Themes\ButtonChrome.cs (4)

303desired = new Size(Math.Min(sideThickness2, availableSize.Width), Math.Min(sideThickness2, availableSize.Height)); 321Width = Math.Max(0d, finalSize.Width - sideThickness2), 322Height = Math.Max(0d, finalSize.Height - sideThickness2)

Microsoft\Windows\Themes\ScrollChrome.cs (4)

339double height = Math.Min(6.0, bounds.Height); 361double width = Math.Min(6.0, bounds.Width); 551double widthScale = Math.Min(glyphWidth, bounds.Width) / glyphWidth; 552double heightScale = Math.Min(glyphHeight, bounds.Height) / glyphHeight;

src\Microsoft.DotNet.Wpf\src\Themes\Shared\Microsoft\Windows\Themes\BulletChrome.cs (6)

187desired = new Size(Math.Min(11.0 + borderX, availableSize.Width), Math.Min(11.0 + borderY, availableSize.Height)); 210Math.Max(0, bounds.Width - thickness.Left - thickness.Right), 211Math.Max(0, bounds.Height - thickness.Top - thickness.Bottom)); 452Math.Max(0.0, rt.Width - thick.Left - thick.Right), 453Math.Max(0.0, rt.Height - thick.Top - thick.Bottom));

src\Microsoft.DotNet.Wpf\src\Themes\Shared\Microsoft\Windows\Themes\DataGridHeaderBorder.cs (5)

192childWidth = Math.Max(0.0, childWidth - padding.Left - padding.Right); 197childHeight = Math.Max(0.0, childHeight - padding.Top - padding.Bottom); 232double childWidth = Math.Max(0.0, arrangeSize.Width - padding.Left - padding.Right); 233double childHeight = Math.Max(0.0, arrangeSize.Height - padding.Top - padding.Bottom); 299return Math.Max(0.0, d);

src\Microsoft.DotNet.Wpf\src\Themes\Shared\Microsoft\Windows\Themes\ProgressBarBrushConverter.cs (2)

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

src\Microsoft.DotNet.Wpf\src\Themes\Shared\Microsoft\Windows\Themes\SystemDropShadowChrome.cs (5)

111double maxRadius = Math.Min(centerWidth * 0.5, centerHeight * 0.5); 112cornerRadius.TopLeft = Math.Min(cornerRadius.TopLeft, maxRadius); 113cornerRadius.TopRight = Math.Min(cornerRadius.TopRight, maxRadius); 114cornerRadius.BottomLeft = Math.Min(cornerRadius.BottomLeft, maxRadius); 115cornerRadius.BottomRight = Math.Min(cornerRadius.BottomRight, maxRadius);

MS\Internal\Documents\CredentialManagerDialog.cs (1)

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

MS\Internal\Documents\SignatureSummaryDialog.cs (4)

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

TenFeetInstallationProgress.xaml.cs (1)

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

AlphaFlattener\BrushProxy.cs (32)

512rb.RadiusX = Math.Abs(rb.RadiusX * bounds.Width); 513rb.RadiusY = Math.Abs(rb.RadiusY * bounds.Height); 1910double length = Math.Sqrt(dx * dx + dy * dy); 1924stopDistance = Math.Max(b.RadiusX, b.RadiusY) * (second.Offset - first.Offset); 1942int stopCount = (int)Math.Ceiling(-6.297427 + 4.591693 * Math.Log(stopDistance)); 2281double height = Math.Abs(start.Y - end.Y) * multiplier; 2290double width = Math.Abs(start.X - end.X) * multiplier; 2572if (Utility.AreClose(new Vector(Math.Abs(rbA.RadiusX), Math.Abs(rbA.RadiusY)) * rbA.Transform.Value, 2573new Vector(Math.Abs(rbB.RadiusX), Math.Abs(rbB.RadiusY)) * rbB.Transform.Value)) 3739min = Math.Min(min, offset); 3740max = Math.Max(max, offset); 3866return Math.Sqrt(sum); 3895return (int)Math.Ceiling(Math.Max(5, step)); // At least five. Radials look bad with less steps. 3944if (Math.Abs(di) < Double.Epsilon) 4038double right = Math.Ceiling(_bounds.Right / _bandDelta); 4039double left = Math.Floor(_bounds.Left / _bandDelta); 4138double rotateAngle = Math.Atan2(-gradientVector.Y, gradientVector.X) * 180.0 / Math.PI; 4183_rx = Math.Abs(b.RadiusX); 4184_ry = Math.Abs(b.RadiusY); 4265double right = Math.Ceiling(maxt * _bandSteps); 4266double left = Math.Floor(mint * _bandSteps); 4383double root = Math.Sqrt(B4AC); 4392maxt = Math.Max(maxt, one); 4393mint = Math.Min(mint, one); 4400maxt = Math.Max(maxt, two); 4401mint = Math.Min(mint, two); 4426double len = Math.Sqrt(dx * dx + dy * dy);

AlphaFlattener\DrawingContext.cs (3)

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

AlphaFlattener\Flattener.cs (2)

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

AlphaFlattener\ImageProxy.cs (6)

480int x0 = (int)Math.Max(Math.Floor(bounds.Left), 0); 481int y0 = (int)Math.Max(Math.Floor(bounds.Top), 0); 482int x1 = (int)Math.Ceiling(bounds.Right); 483int y1 = (int)Math.Ceiling(bounds.Bottom);

AlphaFlattener\Optimizer.cs (2)

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

AlphaFlattener\Primitive.cs (2)

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

AlphaFlattener\Utility.cs (10)

103return Math.Abs(value - 1.0) < Epsilon; 112return Math.Abs(value) < Epsilon; 149double s = Math.Round(scale); 174scale = Math.Sqrt(A); 185x = Math.Abs(x); 186y = Math.Abs(y); 207return y * Math.Sqrt(r * r + 1.0); 223return Math.Max(GetScaleX(trans), GetScaleY(trans)); 1678scale = Math.Min(viewport.Width / viewbox.Width, viewport.Height / viewbox.Height); 1687scale = Math.Max(viewport.Width / viewbox.Width, viewport.Height / viewbox.Height);

MS\Internal\Printing\Configuration\COMPSTUISRID.cs (2)

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

MS\Internal\Printing\Configuration\DevMode.cs (1)

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

PrintConfig\FallbackPTProvider.cs (2)

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

PrintConfig\PrintSchemaShim.cs (2)

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

PrintConfig\PTProvider.cs (5)

674int bytesToWrite = Math.Min(data.Length, (int)(byteCount - totalBytesWritten)); 728int bytesToRead = Math.Min(data.Length, (int)(byteCount - totalBytesRead)); 816return (int)Math.Max(0, Math.Min(value, int.MaxValue)); 821return (int)Math.Min(value, int.MaxValue);

Serialization\DrawingContextFlattener.cs (12)

462private const double PI_OVER_180 = Math.PI / 180; // PI/180 571rAngle = Math.Atan2(rSinArcAngle, rCosArcAngle); 577rAngle += Math.PI * 2; 584rAngle -= Math.PI * 2; 589rCosArcAngle = Math.Cos(rAngle); 590rSinArcAngle = Math.Sin(rAngle); 669rSin = Math.Sqrt(rSin); // = R*cos(a) 670rCos = Math.Sqrt(rCos); // = R*sin(a) 751double rCos = Math.Cos(rRotation); 752double rSin = Math.Sin(rRotation); 773r = Math.Sqrt(rHalfChord2); 787r = Math.Sqrt((1 - rHalfChord2) / rHalfChord2);

Serialization\Manager\ReachSerializationUtils.cs (2)

167System.Windows.DependencyProperty[] newList = new System.Windows.DependencyProperty[Math.Max(List.Length * 2, Count + delta)]; 174List = new System.Windows.DependencyProperty[Math.Max(delta, 2)];

Serialization\VisualSerializer.cs (10)

467scalex = Math.Min(dstwidth / srcwidth, dstheight / srcheight); 472scalex = Math.Max(dstwidth / srcwidth, dstheight / srcheight); 749WriteAttr("RadiusX", Math.Abs(rb.RadiusX * bounds.Width)); 750WriteAttr("RadiusY", Math.Abs(rb.RadiusY * bounds.Height)); 916WriteAttr("StrokeThickness", Math.Abs(pen.Thickness)); 926WriteAttr("StrokeMiterLimit", Math.Max(1.0, pen.MiterLimit)); 948dashes.Add(Math.Abs(d)); 2258WriteAttr("Opacity", Math.Min(Math.Max( opacity, 0.0),1.0)); 2321SetCoordinateFormat(Math.Min(Utility.GetScaleX(mat), Utility.GetScaleY(mat)));

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.AssemblyMetricData.cs (1)

59depthOfInheritance = Math.Max(child.DepthOfInheritance.GetValueOrDefault(), depthOfInheritance);

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.FieldMetricData.cs (4)

47double computationalComplexityVolume = Math.Max(0.0, Math.Log(computationalComplexityMetrics.Volume)); //avoid Log(0) = -Infinity 48double logEffectiveLinesOfCode = Math.Max(0.0, Math.Log(computationalComplexityMetrics.EffectiveLinesOfCode)); //avoid Log(0) = -Infinity

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.MethodMetricData.cs (4)

58double computationalComplexityVolume = Math.Max(0.0, Math.Log(computationalComplexityMetrics.Volume)); //avoid Log(0) = -Infinity 59double logEffectiveLinesOfCode = Math.Max(0.0, Math.Log(computationalComplexityMetrics.EffectiveLinesOfCode)); //avoid Log(0) = -Infinity

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.NamedTypeMetricData.cs (4)

175double logAvgComputationalComplexityVolume = Math.Max(0.0, Math.Log(avgComputationalComplexityVolume)); //avoid Log(0) = -Infinity 176double logAvgLinesOfCode = Math.Max(0.0, Math.Log(avgEffectiveLinesOfCode)); //avoid Log(0) = -Infinity

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.NamespaceMetricData.cs (1)

57depthOfInheritance = Math.Max(child.DepthOfInheritance.GetValueOrDefault(), depthOfInheritance);

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\ComputationalComplexityMetrics.cs (2)

437=> Length * Math.Max(0.0, Math.Log(Vocabulary, 2));

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (3)

33private static int RoundMetricValue(double value) => (int)Math.Round(value, 0); 37maintIndex = Math.Max(0.0, maintIndex); 93var additionalNewLines = Math.Max(0, GetNewlineCount(declSyntax.GetLeadingTrivia(), leading: true) + GetNewlineCount(declSyntax.GetTrailingTrivia(), leading: false) - 1);

src\RoslynAnalyzers\Utilities\Compiler\SmallDictionary.cs (3)

178return 1 + Math.Max(a, b); 303Math.Abs(a - b) >= 2) 308return 1 + Math.Max(a, b);

src\RoslynAnalyzers\Utilities\Refactoring\AbstractSyntaxFacts.cs (1)

84return Math.Min(afterAttributesToken.Span.Start, node.Span.End);

src\RoslynAnalyzers\Utilities\Refactoring\Extensions\ISyntaxFactsExtensions.cs (1)

32var startOfNodeWithoutAttributes = Math.Min(afterAttributesToken.Span.Start, endOfNode);

PerfMargin\StatusIndicator.xaml.cs (1)

65this.clipScale.ScaleX = Math.Max(this.clipScale.ScaleX, MinimumScale);

Services\PerformanceTrackerServiceTests.cs (1)

157to = Math.Min(to, dataCount);

ScenarioTestTypes.cs (1)

1037var numberOfBytesInThisRead = (int)Math.Min(count, _length - _position);

ServerSentEvents\PooledByteBufferWriter.cs (2)

20_buffer.EnsureAvailableSpace(Math.Max(sizeHint, MinimumBufferSize)); 26_buffer.EnsureAvailableSpace(Math.Max(sizeHint, MinimumBufferSize));

ServerSentEvents\SseParser_1.cs (1)

561buffer = ArrayPool<byte>.Shared.Rent(Math.Max(minimumLength, DefaultArrayPoolRentSize));

Hubs\UploadHub.cs (2)

44return $"{winner} wins with a total of {Math.Max(p1score, p2score)} points to {Math.Min(p1score, p2score)}";

src\Servers\Kestrel\test\FunctionalTests\MaxRequestBufferSizeTests.cs (2)

149var size = Math.Min(data.Length - bytesWritten, maxSendSize); 242var size = Math.Min(data.Length - bytesWritten, maxSendSize);

src\Servers\Kestrel\test\FunctionalTests\ResponseTests.cs (1)

1128var received = await stream.ReadAsync(receiveBuffer, 0, Math.Min(receiveBuffer.Length, expectedBytes - totalReceived));

TraceCreator.cs (1)

111var activityLinkCount = Random.Shared.Next(0, Math.Min(5, _allActivities.Count));

SwaggathererApplication.cs (2)

257var length = Math.Min(text.Length, Math.Max(5, part.Name.Length));

src\libraries\System.Private.CoreLib\src\System\Collections\HashHelpers.cs (1)

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

System\Collections\Generic\PriorityQueue.cs (4)

62Debug.Assert(Log2Arity > 0 && Math.Pow(2, Log2Arity) == Arity); 643newcapacity = Math.Max(newcapacity, _nodes.Length + MinimumGrow); 805int childIndexUpperBound = Math.Min(i + Arity, size); 854int childIndexUpperBound = Math.Min(i + Arity, size);

src\libraries\System.Private.CoreLib\src\System\Collections\HashHelpers.cs (1)

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

System\Collections\Concurrent\ConcurrentDictionary.cs (4)

288ICollection<KeyValuePair<TKey, TValue>> c => Math.Max(DefaultCapacity, c.Count), 289IReadOnlyCollection<KeyValuePair<TKey, TValue>> rc => Math.Max(DefaultCapacity, rc.Count), 727_budget = Math.Max(1, newTables._buckets.Length / newTables._locks.Length); 2067_budget = Math.Max(1, newBuckets.Length / newLocks.Length);

System\Collections\Concurrent\PartitionerStatic.cs (3)

451requestedChunkSize = Math.Min(_currentChunkSize.Value * 2, _maxChunkSize); 1101long newSharedIndex = Math.Min(SourceCount - 1, oldSharedIndex + requestedChunkSize); 1370(int quotient, int remainder) = Math.DivRem(SourceCount, partitionCount);

src\libraries\System.Private.CoreLib\src\System\Collections\HashHelpers.cs (1)

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

System\Collections\Frozen\FrozenHashTable.cs (1)

226Array.Clear(seenBuckets, 0, Math.Min(numBuckets, seenBuckets.Length));

System\Collections\Frozen\Integer\DenseIntegralFrozenDictionary.cs (1)

71long maxAllowedLength = Math.Min((long)count * LengthToCountFactor, Array.MaxLength);

System\Collections\Frozen\String\KeyAnalyzer.cs (1)

74int maxSubstringLength = Math.Min(minLength, MaxSubstringLengthLimit);

System\Collections\Immutable\ImmutableArray_1.Builder.cs (1)

741int newCapacity = Math.Max(_elements.Length * 2, capacity);

System\Collections\Immutable\ImmutableList_1.Node.cs (1)

1517private static byte ParentHeight(Node left, Node right) => checked((byte)(1 + Math.Max(left._height, right._height)));

System\Collections\Immutable\ImmutableSortedDictionary_2.Node.cs (2)

88_height = checked((byte)(1 + Math.Max(left._height, right._height))); 774_height = checked((byte)(1 + Math.Max(_left._height, _right._height)));

System\Collections\Immutable\ImmutableSortedSet_1.Node.cs (2)

90_height = checked((byte)(1 + Math.Max(left._height, right._height))); 765_height = checked((byte)(1 + Math.Max(_left._height, _right._height)));

System\Collections\Immutable\SortedInt32KeyNode.cs (2)

91_height = checked((byte)(1 + Math.Max(left._height, right._height))); 555_height = checked((byte)(1 + Math.Max(_left._height, _right._height)));

System\ComponentModel\Container.cs (1)

228for (int i = 0; i < Math.Min(_siteCount, _sites!.Length); i++)

System\ComponentModel\EventDescriptorCollection.cs (1)

159int newSize = Math.Max(sizeNeeded, _events.Length * 2);

System\ComponentModel\PropertyDescriptorCollection.cs (1)

166int newSize = Math.Max(sizeNeeded, _properties.Length * 2);

System\Timers\Timer.cs (3)

56double roundedInterval = Math.Ceiling(interval); 139int i = (int)Math.Ceiling(_interval); 156int i = (int)Math.Ceiling(_interval);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (2)

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

System\TermInfo.Database.cs (1)

240lastEnd = Math.Max(end, lastEnd);

System\Data\Common\AdapterUtil.Common.cs (1)

794startIndex = Math.Min(startIndex, index);

System\Data\Common\ByteStorage.cs (3)

95return Math.Sqrt(var); 108min = Math.Min(_values[record], min); 124max = Math.Max(_values[record], max);

System\Data\Common\DBCommandBuilder.cs (1)

241int maxPrefixLength = Math.Max(

System\Data\Common\DbDataAdapter.cs (1)

987int maxBatchCommands = Math.Min(UpdateBatchSize, dataRows.Length);

System\Data\Common\DecimalStorage.cs (3)

98return Math.Sqrt(var); 111min = Math.Min(_values[record], min); 128max = Math.Max(_values[record], max);

System\Data\Common\DoubleStorage.cs (3)

95return Math.Sqrt(var); 108min = Math.Min(_values[record], min); 124max = Math.Max(_values[record], max);

System\Data\Common\Int16Storage.cs (3)

98return Math.Sqrt(var); 112min = Math.Min(_values[record], min); 129max = Math.Max(_values[record], max);

System\Data\Common\Int32Storage.cs (3)

98return Math.Sqrt(var); 111min = Math.Min(_values[record], min); 128max = Math.Max(_values[record], max);

System\Data\Common\Int64Storage.cs (3)

98return Math.Sqrt(var); 111min = Math.Min(_values[record], min); 128max = Math.Max(_values[record], max);

System\Data\Common\ObjectStorage.cs (1)

310Array.Copy(_values, newValues, Math.Min(capacity, _values.Length));

System\Data\Common\SByteStorage.cs (3)

95return Math.Sqrt(var); 108min = Math.Min(_values[record], min); 124max = Math.Max(_values[record], max);

System\Data\Common\SingleStorage.cs (3)

95return Math.Sqrt(var); 109min = Math.Min(_values[record], min); 125max = Math.Max(_values[record], max);

System\Data\Common\SQLTypes\SQLByteStorage.cs (1)

97return Math.Sqrt(var.Value);

System\Data\Common\SQLTypes\SQLDecimalStorage.cs (1)

97return Math.Sqrt(var.Value);

System\Data\Common\SQLTypes\SQLDoubleStorage.cs (1)

97return Math.Sqrt(var.Value);

System\Data\Common\SQLTypes\SQLInt16Storage.cs (1)

97return Math.Sqrt(var.Value);

System\Data\Common\SQLTypes\SQLInt32Storage.cs (1)

97return Math.Sqrt(var.Value);

System\Data\Common\SQLTypes\SQLInt64Storage.cs (1)

97return Math.Sqrt(var.Value);

System\Data\Common\SQLTypes\SQLMoneyStorage.cs (1)

97return Math.Sqrt(var.Value);

System\Data\Common\SQLTypes\SQLSingleStorage.cs (1)

97return Math.Sqrt(var.Value);

System\Data\Common\StringStorage.cs (1)

185Array.Copy(_values, newValues, Math.Min(capacity, _values.Length));

System\Data\Common\TimeSpanStorage.cs (4)

82return TimeSpan.FromTicks((long)Math.Round(sum)); 100return TimeSpan.FromTicks((long)Math.Round(meanSum / meanCount)); 129ulong stDev = (ulong)Math.Round(Math.Sqrt(varSum / (count - 1)));

System\Data\Common\UInt16Storage.cs (3)

98return Math.Sqrt(var); 111min = Math.Min(_values[record], min); 128max = Math.Max(_values[record], max);

System\Data\Common\UInt32Storage.cs (3)

98return Math.Sqrt(var); 111min = Math.Min(_values[record], min); 128max = Math.Max(_values[record], max);

System\Data\Common\UInt64Storage.cs (3)

98return Math.Sqrt(var); 111min = Math.Min(_values[record], min); 128max = Math.Max(_values[record], max);

System\Data\DataColumn.cs (1)

934_maxLength = Math.Max(value, -1);

System\Data\DataError.cs (1)

141int newCapacity = Math.Min(_count * 2, column.Table!.Columns.Count);

System\Data\DataTableReader.cs (2)

368int byteCount = Math.Min(tempBuffer.Length - srcIndex, length); 431int charCount = Math.Min(tempBuffer.Length - srcIndex, length);

System\Data\Filter\BinaryNode.cs (2)

1323DataTypePrecedence higherPrec = (DataTypePrecedence)Math.Max(leftPrecedence, rightPrecedence); 1437DataTypePrecedence higherPrec = (DataTypePrecedence)Math.Max(leftPrecedence, rightPrecedence);

System\Data\Filter\FunctionNode.cs (2)

325return (Math.Abs((long)argumentValues[0])); 327return (Math.Abs((double)argumentValues[0]));

System\Data\ProviderBase\SchemaMapping.cs (2)

299Debug.Assert(_mappedLength == Math.Min(_readerDataValues!.Length, _mappedDataValues!.Length), "incorrect precomputed length"); 1240_mappedLength = Math.Min(count, mappingCount);

System\Data\RecordManager.cs (1)

39Array.Copy(_rows, newRows, Math.Min(_lastFreeRecord, _rows.Length));

System\Data\SQLTypes\SQLBytes.cs (1)

326int count = Math.Min(buffer.Length, (int)(Length - offset));

System\Data\SQLTypes\SQLDecimal.cs (26)

414precision = Math.Max(precision, _bScale); 680double dInt = Math.Floor(dVal); 687dVal = Math.Floor(dInt / s_DUINT_BASE); 693dVal = Math.Floor(dInt / s_DUINT_BASE); 700dVal = Math.Floor(dInt / s_DUINT_BASE); 707dVal = Math.Floor(dInt / s_DUINT_BASE); 766dFrac -= Math.Floor(dFrac); 1138dRet /= System.Math.Pow(10.0, _bScale); 1251ResInteger = Math.Max(x._bPrec - MyScale, y._bPrec - OpScale); 1255ResScale = Math.Max(MyScale, OpScale); 1261ResPrec = Math.Min(MaxPrecision, ResPrec); 1465ResScale = Math.Min((ResPrec - ResInteger), ResScale); 1467ResScale = Math.Max(ResScale, Math.Min(ActualScale, s_cNumeDivScaleMin)); 1688ResScale = Math.Max(x._bScale + y._bPrec + 1, s_cNumeDivScaleMin); 1691MinScale = Math.Min(ResScale, s_cNumeDivScaleMin); 1693ResInteger = Math.Min(ResInteger, s_NUMERIC_MAX_PRECISION); 1700ResScale = Math.Min((ResPrec - ResInteger), ResScale); 1701ResScale = Math.Max(ResScale, MinScale); 2297bNewPrec = (byte)(Math.Min(s_NUMERIC_MAX_PRECISION, Math.Max(1, lAdjust + _bPrec))); 3168lPosition = Math.Min(s_NUMERIC_MAX_PRECISION, lPosition); 3175lPosition = Math.Max(-s_NUMERIC_MAX_PRECISION, lPosition); 3186int lAdjust = Math.Abs(lPosition - n._bScale); // Precision adjustment 3225lAdjust = Math.Abs(lPosition - n._bScale); 3261n = new SqlDecimal(Math.Pow(dBaseNum, exp));

Common\System\Data\ProviderBase\DbConnectionPool.cs (1)

617delay = (uint)Math.Max(ADP.TimerRemainingMilliseconds(next.DueTime), 0);

src\libraries\Common\src\System\Data\ProviderBase\DbMetaDataFactory.cs (1)

127command.CommandTimeout = Math.Max(command.CommandTimeout, 180);

System\Data\Odbc\OdbcConnection.cs (2)

399value = (BitConverter.IsLittleEndian ? Encoding.Unicode : Encoding.BigEndianUnicode).GetString(buffer, 0, Math.Min(cbActual, buffer.Length)); 501value = (BitConverter.IsLittleEndian ? Encoding.Unicode : Encoding.BigEndianUnicode).GetString(buffer, 0, Math.Min(cbActual, buffer.Length));

System\Data\Odbc\OdbcDataReader.cs (12)

571int nValues = Math.Min(values.Length, FieldCount); 972string strdata = buffer.PtrToStringUni(0, Math.Min(lengthOrIndicator, cbMaxData) / 2); 1013cbActual = Math.Min(lengthOrIndicator, cbMaxData); 1185int lengthOfCopy = Math.Min(lengthFromDataIndex, length); 1188lengthOfCopy = Math.Min(lengthOfCopy, buffer.Length - bufferIndex); 1308length = Math.Min(length, buffer.Length - bufferIndex); 1370cbReadMax = (int)Math.Min(cbLength, internalNativeBuffer.Length - 4); 1379cbReadMax = (int)Math.Min(cbLength, internalNativeBuffer.Length - 2); 1476Buffer.ReadBytes(0, rgBytes, cbOffset, Math.Min(cbActual, cbBufferLen)); 1489buffer.ReadBytes(0, rgBytes, cbOffset, Math.Min(cbActual, cbBufferLen)); 2277row[columnSize] = unchecked((int)Math.Min(Math.Max(int.MinValue, _metadata![i].size.ToInt64()), int.MaxValue));

System\Data\Odbc\OdbcParameter.cs (8)

322return Math.Min((int)_internalPrecision, ADP.DecimalMaxPrecision); 353cch = Math.Max(cch, 4 * 1024); // MDAC 69224 378cch = Math.Max(cch, 4 * 1024); // MDAC 69224 395cch = Math.Max(cch, 8 * 1024); // MDAC 69224 406cch = Math.Max(2, cch); 422return Math.Min((int)_internalPrecision, ADP.DecimalMaxPrecision); 510ccb = Math.Max(ccb, 8 * 1024); // MDAC 69224 546_internalPrecision = Math.Max(_internalPrecision, precision); // silently adjust the precision

System\Data\Odbc\OdbcUtils.cs (4)

39cb = Math.Min(cb / 2, (Length - 2) / 2); 47cb = Math.Min(cb, Length); 172length = Math.Max(0, ((string)value).Length - valueOffset); 187length = Math.Max(0, ((char[])value).Length - valueOffset);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (2)

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

System\Diagnostics\DsesSamplerBuilder.cs (1)

51return Math.Abs(GetLowerLong(traceIdBytes)) < idUpperBound

System\Diagnostics\Metrics\AggregationManager.cs (1)

219double alignUpSecsSinceStart = Math.Ceiling(secsSinceStart / collectionIntervalSecs) *

System\Diagnostics\Metrics\CounterAggregator.cs (1)

21private readonly PaddedDouble[] _deltas = new PaddedDouble[Math.Min(Environment.ProcessorCount, 8)];

System\Diagnostics\Metrics\ExponentialHistogramAggregator.cs (4)

77int mantissaBits = (int)Math.Ceiling(Math.Log(1 / _config.MaxRelativeError, 2)) - 1; 201return Math.Min(Math.Max(0, (int)(quantile * count)), count - 1);

System\Diagnostics\Metrics\RuntimeMetrics.cs (1)

21private static readonly int s_maxGenerations = Math.Min(GC.GetGCMemoryInfo().GenerationInfo.Length, s_genNames.Length);

src\libraries\Common\src\System\Collections\Generic\ArrayBuilder.cs (2)

148nextCapacity = Math.Max(capacity + 1, Array.MaxLength); 151nextCapacity = Math.Max(nextCapacity, minimum);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (2)

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

System\Diagnostics\ProcessWaitState.Unix.cs (2)

427(int)Math.Max(millisecondsTimeout - Stopwatch.GetElapsedTime(startTime).TotalMilliseconds, 0); 538pollingIntervalMs = Math.Min(pollingIntervalMs * 2, MaxPollingIntervalMs);

System\Diagnostics\XmlWriterTraceListener.cs (1)

231InternalWrite(Math.Clamp((int)eventType, 0, 255));

mono\System.Drawing\BitmapTests.cs (6)

223Assert.Equal(Math.Ceiling((float)c.B * c.A / 255), data[0]); 224Assert.Equal(Math.Ceiling((float)c.G * c.A / 255), data[1]); 225Assert.Equal(Math.Ceiling((float)c.R * c.A / 255), data[2]); 227Assert.Equal(Math.Ceiling((float)d.B * d.A / 255), data[4]); 228Assert.Equal(Math.Ceiling((float)d.G * d.A / 255), data[5]); 229Assert.Equal(Math.Ceiling((float)d.R * d.A / 255), data[6]);

System\Drawing\BitmapTests.cs (6)

1355Assert.Equal(Math.Ceiling((float)c.B * c.A / 255), data[0]); 1356Assert.Equal(Math.Ceiling((float)c.G * c.A / 255), data[1]); 1357Assert.Equal(Math.Ceiling((float)c.R * c.A / 255), data[2]); 1359Assert.Equal(Math.Ceiling((float)d.B * d.A / 255), data[4]); 1360Assert.Equal(Math.Ceiling((float)d.G * d.A / 255), data[5]); 1361Assert.Equal(Math.Ceiling((float)d.R * d.A / 255), data[6]);

System\Drawing\Drawing2D\GraphicsPathTests.cs (1)

30private const float Pi4 = (float)(Math.PI / 4);

System\Drawing\FontTests.cs (1)

494Assert.Equal((int)Math.Ceiling(height), font.Height);

System\Drawing\IconTests.cs (1)

117public override int Read(byte[] buffer, int offset, int count) => base.Read(buffer, offset, Math.Min(count, 1));

System\Drawing\Point.cs (4)

123public static Point Ceiling(PointF value) => new Point(unchecked((int)Math.Ceiling(value.X)), unchecked((int)Math.Ceiling(value.Y))); 133public static Point Round(PointF value) => new Point(unchecked((int)Math.Round(value.X)), unchecked((int)Math.Round(value.Y)));

System\Drawing\Rectangle.cs (16)

182(int)Math.Ceiling(value.X), 183(int)Math.Ceiling(value.Y), 184(int)Math.Ceiling(value.Width), 185(int)Math.Ceiling(value.Height)); 212(int)Math.Round(value.X), 213(int)Math.Round(value.Y), 214(int)Math.Round(value.Width), 215(int)Math.Round(value.Height)); 290int x1 = Math.Max(a.X, b.X); 291int x2 = Math.Min(a.X + a.Width, b.X + b.Width); 292int y1 = Math.Max(a.Y, b.Y); 293int y2 = Math.Min(a.Y + a.Height, b.Y + b.Height); 315int x1 = Math.Min(a.X, b.X); 316int x2 = Math.Max(a.X + a.Width, b.X + b.Width); 317int y1 = Math.Min(a.Y, b.Y); 318int y2 = Math.Max(a.Y + a.Height, b.Y + b.Height);

System\Drawing\RectangleF.cs (8)

273float x1 = Math.Max(a.X, b.X); 274float x2 = Math.Min(a.X + a.Width, b.X + b.Width); 275float y1 = Math.Max(a.Y, b.Y); 276float y2 = Math.Min(a.Y + a.Height, b.Y + b.Height); 297float x1 = Math.Min(a.X, b.X); 298float x2 = Math.Max(a.X + a.Width, b.X + b.Width); 299float y1 = Math.Min(a.Y, b.Y); 300float y2 = Math.Max(a.Y + a.Height, b.Y + b.Height);

System\Drawing\Size.cs (4)

157new Size(unchecked((int)Math.Ceiling(value.Width)), unchecked((int)Math.Ceiling(value.Height))); 174new Size(unchecked((int)Math.Round(value.Width)), unchecked((int)Math.Round(value.Height)));

System\Formats\Asn1\AsnDecoder.cs (1)

641int len = Math.Min(longestPermitted, source.Length);

System\Formats\Asn1\AsnDecoder.Oid.cs (1)

208idx = Math.Max(0, nextStop - ContentByteCount);

System\Formats\Asn1\AsnWriter.BitString.cs (1)

113int fullSegments = Math.DivRem(contentLength, MaxCERContentSize, out int lastContentSize);

System\Formats\Asn1\AsnWriter.OctetString.cs (1)

111int fullSegments = Math.DivRem(payload.Length, MaxCERSegmentSize, out int lastSegmentSize);

System\Formats\Asn1\AsnWriter.Oid.cs (1)

173oidValue = oidValue.Slice(Math.Min(oidValue.Length, endIndex + 1));

System\Formats\Asn1\SetOfValueComparer.cs (1)

17int min = Math.Min(x.Length, y.Length);

System\Formats\Nrbf\ArraySinglePrimitiveRecord.cs (2)

134int sliceSize = Math.Min(valuesToRead.Length, MaxChunkLength); 256List<T> values = new List<T>(Math.Min(count, 4));

System\Formats\Nrbf\RectangularArrayRecord.cs (1)

30_records = new List<SerializationRecord>(Math.Min(4, arrayInfo.GetSZArrayLength()));

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (2)

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

System\Formats\Tar\SeekableSubReadStream.cs (1)

54count = Math.Max(0, (int)(_endInSuperStream - _positionInSuperStream));

System\Formats\Tar\TarHeader.Write.cs (2)

1059int numToCopy = Math.Min(bytesToWrite.Length, destination.Length); 1076int numToCopy = Math.Min(bytesToWrite.Length, destination.Length - 1);

System\Formats\Tar\TarHelpers.cs (8)

System\IO\Compression\DeflateManaged\InflaterManaged.cs (1)

115bytes = bytes.Slice(0, (int)Math.Min(bytes.Length, _uncompressedSize - _currentInflatedCount));

System\IO\Compression\DeflateManaged\InputBuffer.cs (1)

149int length = Math.Min(output.Length, _buffer.Length);

System\IO\Compression\DeflateManaged\OutputWindow.cs (2)

88length = Math.Min(Math.Min(length, WindowSize - _bytesUsed), input.AvailableBytes);

System\IO\Compression\DeflateZLib\Inflater.cs (1)

101length = (int)Math.Min(length, _uncompressedSize - _currentInflatedCount);

System\IO\Compression\ZipArchive.cs (3)

716nextFileOffset = Math.Max(nextFileOffset, entry.GetOffsetOfCompressedData() + entry.CompressedLength); 721startingOffset = Math.Min(startingOffset, entry.OffsetOfLocalHeader); 732completeRewriteStartingOffset = Math.Min(completeRewriteStartingOffset, entry.OffsetOfLocalHeader);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (2)

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

System\IO\Hashing\XxHashShared.cs (1)

456return Math.BigMul(left, right, out lower);

System\IO\Pipelines\Pipe.cs (3)

262sizeHint = Math.Max(MinimumSegmentSize, sizeHint); 264int adjustedToMaximumSize = Math.Min(maxBufferSize, sizeHint); 1104int writable = Math.Min(destination.Length, source.Length);

System\IO\Pipelines\PipeReaderStream.cs (1)

126int actual = (int)Math.Min(bufferLength, buffer.Length);

System\IO\Pipelines\StreamPipeReader.cs (2)

537sizeHint = Math.Max(BufferSize, sizeHint); 539int adjustedToMaximumSize = Math.Min(maxBufferSize, sizeHint);

System\IO\Pipelines\StreamPipeWriter.cs (2)

178sizeHint = Math.Max(_minimumBufferSize, sizeHint); 180var adjustedToMaximumSize = Math.Min(maxBufferSize, sizeHint);

System\IO\Ports\SerialPort.cs (4)

675bytesReadToBuffer = Math.Min(CachedBytesToRead, count); 891int bytesToRead = Math.Min(count, CachedBytesToRead); 923currentBytesToExamine = Math.Min(count - totalCharsFound, _readLen - _readPos - totalBytesExamined); 1330int newLength = Math.Max(CachedBytesToRead + additionalByteLength, _inBuffer.Length * 2);

System\IO\Ports\SerialStream.Unix.cs (1)

1070new CancellationTokenSource(Math.Max(timeoutMs, TimeoutResolution));

System\Linq\Chunk.cs (3)

66TSource[] chunk = new ReadOnlySpan<TSource>(source, index, Math.Min(size, source.Length - index)).ToArray(); 82int arraySize = Math.Min(size, 4); 99arraySize = (int)Math.Min((uint)size, 2 * (uint)array.Length);

System\Linq\SegmentedArrayBuilder.cs (3)

145ReadOnlySpan<T> sourceSlice = sourceSpan.Slice(0, Math.Min(availableSpaceInCurrentSpan, sourceSpan.Length)); 354int newSegmentLength = (int)Math.Min(Math.Max(minimumRequired, currentSegmentLength * 2L), Array.MaxLength);

System\Linq\Select.SpeedOpt.cs (2)

927return _selector(_source[Math.Min(lastIndex, _maxIndexInclusive)]); 944return Math.Min(count - 1, _maxIndexInclusive) - _minIndexInclusive + 1;

System\Linq\Shuffle.SpeedOpt.cs (5)

154TryGetNonEnumeratedCount(_source, out int count) ? Math.Min(_takeCount, count) : 170if ((uint)index < (uint)Math.Min(_takeCount, iteratorCount)) 178if ((uint)index < (uint)Math.Min(_takeCount, count)) 187if (sample is not null && index < Math.Min(_takeCount, totalElementCount)) 239reservoir = new List<TSource>(Math.Min(takeCount, 4)) { e.Current };

System\Linq\SkipTake.SpeedOpt.cs (4)

97return _source[Math.Min(lastIndex, _maxIndexInclusive)]; 113return Math.Min(sourceCount - 1, maxIndexInclusive) - minIndexInclusive + 1; 273return Math.Max(_source.Count() - _minIndexInclusive, 0); 288return Math.Max((int)count - _minIndexInclusive, 0);

System\Linq\Take.cs (3)

144Debug.Assert(queue.Count == Math.Min(count, startIndex)); 193Math.Max(0, isStartIndexFromEnd ? count - startIndex : startIndex); 196Math.Min(count, isEndIndexFromEnd ? count - endIndex : endIndex);

System\Linq\Chunk.cs (2)

50int arraySize = Math.Min(size, 4); 67arraySize = (int)Math.Min((uint)size, 2 * (uint)array.Length);

System\Linq\Take.cs (3)

173Debug.Assert(queue.Count == Math.Min(count, startIndex)); 223Math.Max(0, count - startIndex); 226Math.Min(count, isEndIndexFromEnd ? count - endIndex : endIndex);

src\libraries\Common\src\System\Collections\Generic\ArrayBuilder.cs (2)

148nextCapacity = Math.Max(capacity + 1, Array.MaxLength); 151nextCapacity = Math.Max(nextCapacity, minimum);

System\Linq\Expressions\Common\CachedReflectionInfo.cs (2)

135s_Math_Pow_Double_Double ??= typeof(Math).GetMethod(nameof(Math.Pow), new[] { typeof(double), typeof(double) })!;

System\Linq\Expressions\Compiler\LambdaCompiler.Statements.cs (1)

419keys.Sort((x, y) => Math.Sign(x.Key - y.Key));

System\Linq\Expressions\DebugViewWriter.cs (1)

203return (Flow)System.Math.Max((int)last, (int)flow);

System\Linq\Expressions\Interpreter\LocalVariables.cs (1)

76_maxLocalCount = Math.Max(_localCount, _maxLocalCount);

System\Runtime\CompilerServices\RuleCache.cs (1)

47int max = Math.Min(_rules.Length, i + count);

System\Linq\Parallel\QueryOperators\Binary\ZipQueryOperator.cs (1)

184_count = Math.Min(_leftChildResults.Count, _rightChildResults.Count);

System\Linq\Parallel\QueryOperators\Unary\TakeOrSkipQueryOperator.cs (2)

377return Math.Min(_childCount, _takeOrSkipOp._count); 381return Math.Max(_childCount - _takeOrSkipOp._count, 0);

System\Linq\Parallel\Scheduling\Scheduling.cs (1)

34internal static readonly int DefaultDegreeOfParallelism = Math.Min(Environment.ProcessorCount, MAX_SUPPORTED_DOP);

System\Linq\Parallel\Utils\Sorting.cs (1)

384_sharedBarriers[phase][Math.Min(_partitionIndex, partnerIndex)].SignalAndWait(cancelToken);

src\libraries\Common\src\System\Buffers\ArrayBufferWriter.cs (2)

214int growBy = Math.Max(sizeHint, currentLength); 218growBy = Math.Max(growBy, DefaultInitialBufferSize);

System\Buffers\BuffersExtensions.cs (1)

137int writeSize = Math.Min(destination.Length, input.Length);

System\Buffers\SequenceReader.cs (1)

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

System\BinaryData.cs (1)

287bufferSize = longLength == 0 ? 1 : Math.Min((int)longLength, CopyToBufferSize);

src\libraries\Common\src\System\Net\ArrayBuffer.cs (2)

161int newSize = Math.Max(desiredSize, (int)Math.Min(ArrayMaxLength, 2 * (uint)_bytes.Length));

src\libraries\Common\src\System\Net\Http\aspnetcore\Http2\Hpack\DynamicTable.cs (3)

79int newBufferSize = Math.Min(Math.Max(16, _buffer.Length * 2), maxCapacity); 84int headCount = Math.Min(_buffer.Length - _removeIndex, _count);

src\libraries\Common\src\System\Net\Http\aspnetcore\Http2\Hpack\HPackDecoder.cs (6)

425int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 463int count = Math.Min(_stringLength - _stringIndex, data.Length - currentIndex); 585_stringOctets = new byte[Math.Max(length, Math.Min(_stringOctets.Length * 2, _maxHeadersLength))]; 634dst = new byte[Math.Max(stringLength, Math.Min(dst.Length * 2, _maxHeadersLength))];

src\libraries\Common\src\System\Net\Http\aspnetcore\Http3\QPack\QPackDecoder.cs (2)

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

src\libraries\Common\src\System\Net\MultiArrayBuffer.cs (1)

140byteCount = Math.Min(byteCount, limit - ActiveMemory.Length);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (2)

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

System\Net\Http\Headers\AltSvcHeaderParser.cs (1)

140maxAge = Math.Min(maxAge.GetValueOrDefault(), maxAgeTmp);

System\Net\Http\HttpContent.cs (5)

928int newBufferCapacity = (int)Math.Min((uint)lastBufferCapacity * ResizeFactor, Array.MaxLength); 931newBufferCapacity = Math.Max(newBufferCapacity, _totalLength + buffer.Length); 938: Math.Min(_expectedFinalSize, MaxInitialBufferSize / LastResizeFactor); 940newBufferCapacity = Math.Max(newBufferCapacity, minCapacity); 947newBufferCapacity = Math.Min(newBufferCapacity, remainingUntilMaxCapacity);

System\Net\Http\SocketsHttpHandler\ChunkedEncodingReadStream.cs (4)

73int bytesRead = _connection.Read(buffer.Slice(0, (int)Math.Min((ulong)buffer.Length, _chunkBytesRemaining))); 189int bytesRead = await _connection.ReadAsync(buffer.Slice(0, (int)Math.Min((ulong)buffer.Length, _chunkBytesRemaining))).ConfigureAwait(false); 367int bytesToConsume = Math.Min(maxBytesToRead, (int)Math.Min((ulong)connectionBuffer.Length, _chunkBytesRemaining));

System\Net\Http\SocketsHttpHandler\ConnectionPool\RequestQueue.cs (1)

93var newArray = new QueueItem[Math.Max(4, _array.Length * 2)];

System\Net\Http\SocketsHttpHandler\ContentLengthReadStream.cs (2)

184int bytesToConsume = Math.Min(maxBytesToRead, (int)Math.Min((ulong)connectionBuffer.Length, _contentBytesRemaining));

System\Net\Http\SocketsHttpHandler\CreditManager.cs (2)

106int granted = Math.Min(waiter.Amount, _current); 169int granted = Math.Min(amount, _current);

System\Net\Http\SocketsHttpHandler\Http2Connection.cs (2)

444string response = Encoding.ASCII.GetString(_incomingBuffer.ActiveSpan.Slice(0, Math.Min(20, _incomingBuffer.ActiveLength))); 1718int frameSize = Math.Min(remaining.Length, FrameHeader.MaxPayloadLength);

System\Net\Http\SocketsHttpHandler\Http2Stream.cs (3)

484int granted = Math.Min(_availableCredit, _creditWaiter.Amount); 1116int bytesRead = Math.Min(buffer.Length, activeBuffer.Length); 1285sendSize = Math.Min(buffer.Length, _availableCredit);

System\Net\Http\SocketsHttpHandler\Http2StreamWindowManager.cs (2)

114int extendedWindowSize = Math.Min(MaxStreamWindowSize, _streamWindowSize * 2); 273long minRtt = Math.Min(prevRtt, currentRtt.Ticks);

System\Net\Http\SocketsHttpHandler\Http3Connection.cs (2)

870_maxHeaderListSize = (uint)Math.Min((ulong)settingValue, uint.MaxValue); 934long readLength = Math.Min(payloadLength, buffer.ActiveLength);

System\Net\Http\SocketsHttpHandler\Http3RequestStream.cs (9)

77_headerDecoder = new QPackDecoder(maxHeadersLength: (int)Math.Min(int.MaxValue, _headerBudgetRemaining)); 939int processLength = (int)Math.Min(headersLength, _recvBuffer.ActiveLength); 1139long readLength = Math.Min(payloadLength, _recvBuffer.ActiveLength); 1170int copyLen = (int)Math.Min(buffer.Length, Math.Min(_responseDataPayloadRemaining, _recvBuffer.ActiveLength)); 1190int copyLen = (int)Math.Min(buffer.Length, _responseDataPayloadRemaining); 1242int copyLen = (int)Math.Min(buffer.Length, Math.Min(_responseDataPayloadRemaining, _recvBuffer.ActiveLength)); 1262int copyLen = (int)Math.Min(buffer.Length, _responseDataPayloadRemaining);

System\Net\Http\SocketsHttpHandler\HttpConnection.cs (3)

1747int toCopy = Math.Min(available.Length, buffer.Length); 1951remaining = (int)Math.Min((ulong)_readBuffer.ActiveLength, length); 1969int desiredBufferSize = (int)Math.Min((ulong)bufferSize, length);

System\Net\Http\SocketsHttpHandler\HttpConnectionPoolManager.cs (2)

114long heartBeatInterval = (long)Math.Max(1000, Math.Min(_settings._keepAlivePingDelay.TotalMilliseconds, _settings._keepAlivePingTimeout.TotalMilliseconds) / 4);

System\Net\Http\SocketsHttpHandler\HttpConnectionSettings.cs (1)

146public int MaxResponseHeadersByteLength => (int)Math.Min(int.MaxValue, _maxResponseHeadersLength * 1024L);

src\libraries\Common\src\System\Net\Logging\NetEventSource.Common.DumpBuffer.cs (1)

35Log.DumpBuffer(IdOf(thisOrContextObject), memberName, buffer.Slice(0, Math.Min(buffer.Length, MaxDumpSize)).ToArray());

System\Net\Managed\ChunkedInputStream.cs (1)

142ares._count = Math.Min(8192, _decoder.ChunkLeft + 6);

System\Net\Managed\HttpListenerRequest.Managed.cs (1)

263length = (int)Math.Min(_contentLength, (long)length);

System\Net\Managed\HttpRequestStream.Managed.cs (6)

76int size = Math.Min(_length, count); 78size = (int)Math.Min(size, _remainingBody); 82size = Math.Min(size, _buffer.Length - _offset); 110size = (int)Math.Min(_remainingBody, (long)size); 149ares._synchRead = Math.Max(0, nread); 158size = (int)Math.Min(_remainingBody, (long)size);

System\Net\Managed\HttpResponseStream.Managed.cs (1)

184int new_count = Math.Min(size, 16384 - (int)ms.Position + (int)start);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (2)

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

System\Net\BufferedReadStream.cs (2)

36int read = Math.Min(buffer.Length, _storedLength - _storedOffset); 58int read = Math.Min(buffer.Length, _storedLength - _storedOffset);

System\Net\Mail\SmtpReplyReaderFactory.cs (2)

327int left = Math.Min(4 - statusRead, actual); 461int left = Math.Min(4 - _statusRead, actual);

System\Net\Mime\SmtpDateTime.cs (1)

343if (Math.Abs(sanitizedTimeSpan.Ticks) > TimeSpanMaxTicks)

src\libraries\Common\src\System\Net\SocketAddressPal.Unix.cs (1)

181buffer[0] = (byte)Math.Min(buffer.Length, 255);

System\Net\NetworkInformation\StringParsingHelpers.Statistics.cs (1)

458return (long)Math.Min(long.MaxValue, ulong.Parse(value, CultureInfo.InvariantCulture));

src\libraries\Common\src\System\Net\NetworkInformation\UnixCommandLinePing.cs (2)

128timeout = Math.DivRem(timeout, millisInSecond, out int remainder); 217return (long)Math.Round(parsedRtt);

src\libraries\Common\src\System\Net\SocketAddressPal.Unix.cs (1)

181buffer[0] = (byte)Math.Min(buffer.Length, 255);

System\Net\NetworkInformation\Ping.PingUtility.cs (1)

140int addressLength = stdout.AsSpan(Math.Max(addressStart, 0)).IndexOfAny(' ', ':');

src\libraries\Common\src\System\Net\SocketAddressPal.Unix.cs (1)

181buffer[0] = (byte)Math.Min(buffer.Length, 255);

System\Net\CookieContainer.cs (3)

385int min_count = Math.Min((int)(domain_count * remainingFraction), Math.Min(m_maxCookiesPerDomain, m_maxCookies) - 1); 956int length = Math.Min(ll, lr);

System\Net\IPAddressParser.cs (4)

174(uint hundredsAndTens, number) = Math.DivRem(number, 10); 175(hundreds, tens) = Math.DivRem(hundredsAndTens, 10); 183(tens, number) = Math.DivRem(number, 10); 228(scopeId, uint digit) = Math.DivRem(scopeId, 10);

src\libraries\Common\src\System\Net\ArrayBuffer.cs (2)

161int newSize = Math.Max(desiredSize, (int)Math.Min(ArrayMaxLength, 2 * (uint)_bytes.Length));

src\libraries\Common\src\System\Net\MultiArrayBuffer.cs (1)

140byteCount = Math.Min(byteCount, limit - ActiveMemory.Length);

src\libraries\Common\src\System\Net\SocketAddressPal.Unix.cs (1)

181buffer[0] = (byte)Math.Min(buffer.Length, 255);

src\libraries\Common\src\System\Net\StreamBuffer.cs (2)

112int bytesWritten = Math.Min(buffer.Length, _buffer.AvailableMemory.Length); 205int bytesRead = Math.Min(buffer.Length, _buffer.ActiveMemory.Length);

System\Net\Quic\Internal\ReceiveBuffers.cs (1)

77copied = Math.Min(buffer.Length, activeBuffer.Length);

System\Net\HttpWebResponse.cs (2)

403int readBytes = innerStream.Read(buffer.Slice(0, (int)Math.Min(buffer.Length, _maxRemainingLength))); 415int readBytes = await innerStream.ReadAsync(buffer.Slice(0, (int)Math.Min(buffer.Length, _maxRemainingLength)), cancellationToken)

System\Net\ServicePoint\ServicePointManager.cs (1)

91set { s_dnsRefreshTimeout = Math.Max(-1, value); }

System\Net\TimerThread.cs (1)

549Math.Min(unchecked((uint)(nextTick - newNow)), (uint)(int.MaxValue - TickCountResolution)) + TickCountResolution :

src\libraries\Common\src\System\Net\ArrayBuffer.cs (2)

161int newSize = Math.Max(desiredSize, (int)Math.Min(ArrayMaxLength, 2 * (uint)_bytes.Length));

src\libraries\Common\src\System\Net\Logging\NetEventSource.Common.DumpBuffer.cs (1)

35Log.DumpBuffer(IdOf(thisOrContextObject), memberName, buffer.Slice(0, Math.Min(buffer.Length, MaxDumpSize)).ToArray());

System\Net\Security\NegotiateStream.cs (3)

354int copyBytes = Math.Min(_readBufferCount, buffer.Length); 430int copyBytes = Math.Min(_readBufferCount, buffer.Length); 520int chunkBytes = Math.Min(buffer.Length, MaxWriteDataSize);

System\Net\Security\SslStream.IO.cs (2)

617int chunkBytes = Math.Min(buffer.Length, MaxDataSize); 1001int copyBytes = Math.Min(_buffer.DecryptedLength, buffer.Length);

src\libraries\Common\src\System\Net\ArrayBuffer.cs (2)

161int newSize = Math.Max(desiredSize, (int)Math.Min(ArrayMaxLength, 2 * (uint)_bytes.Length));

System\Net\ServerSentEvents\PooledByteBufferWriter.cs (2)

18_buffer.EnsureAvailableSpace(Math.Max(sizeHint, MinimumBufferSize)); 24_buffer.EnsureAvailableSpace(Math.Max(sizeHint, MinimumBufferSize));

System\Net\ServerSentEvents\SseParser_1.cs (1)

537buffer = ArrayPool<byte>.Shared.Rent(Math.Max(minimumLength, DefaultArrayPoolRentSize));

src\libraries\Common\src\System\Net\Logging\NetEventSource.Common.DumpBuffer.cs (1)

35Log.DumpBuffer(IdOf(thisOrContextObject), memberName, buffer.Slice(0, Math.Min(buffer.Length, MaxDumpSize)).ToArray());

src\libraries\Common\src\System\Net\SocketAddressPal.Unix.cs (1)

181buffer[0] = (byte)Math.Min(buffer.Length, 255);

System\Net\Sockets\SocketAsyncEngine.Unix.cs (4)

58return Math.Max(1, (int)Math.Round(Environment.ProcessorCount / (double)coresPerEngine)); 117int engineIndex = Math.Abs(Interlocked.Increment(ref s_allocateFromEngine) % s_engines.Length); 133int newLength = Math.Max(4, 2 * previousLength);

System\Net\Sockets\SocketPal.Unix.cs (3)

296maxBuffers = Math.Max(maxBuffers, 1); 388maxBuffers = Math.Max(maxBuffers, 1); 549buffersCount = Math.Max(buffersCount, 1);

src\libraries\Common\src\System\IO\ChunkedMemoryStream.cs (2)

50int toCopy = Math.Min(remaining, buffer.Length); 90nextChunkLength = (int)Math.Min(count, MaxChunkSize);

System\Net\WebClient.cs (4)

527buffSize = (int)Math.Min(DefaultCopyBufferLength, fs.Length); 540buffSize = (int)Math.Min(DefaultCopyBufferLength, fs.Length); 1435chunkSize = (int)Math.Min((long)DefaultCopyBufferLength, data.Length); 1511chunkSize = (int)Math.Min((long)DefaultCopyBufferLength, buffer.Length);

System\Net\WebSockets\Compression\WebSocketDeflater.cs (1)

49_buffer = ArrayPool<byte>.Shared.Rent(Math.Max(payload.Length, MinInitialBufferLength));

System\Net\WebSockets\Compression\WebSocketInflater.cs (1)

83_buffer = ArrayPool<byte>.Shared.Rent((int)Math.Min(userBufferLength, payloadLength));

System\Net\WebSockets\ManagedWebSocket.cs (2)

924int limit = (int)Math.Min(header.Compressed ? _inflater!.Span.Length : payloadBuffer.Length, header.PayloadLength); 928int receiveBufferBytesToCopy = Math.Min(limit, _receiveBufferCount);

System\Net\WebSockets\ManagedWebSocket.KeepAlive.cs (3)

135internal int HeartBeatIntervalMs => Math.Max(Math.Min(DelayMs, TimeoutMs) / 4, MinIntervalMs); 151static int TimeSpanToMs(TimeSpan value) => (int)Math.Clamp((long)value.TotalMilliseconds, MinIntervalMs, int.MaxValue);

System\Net\WebSockets\WebSocket.cs (1)

117return new ArraySegment<byte>(new byte[Math.Max(receiveBufferSize, sendBufferSize)]);

System\Numerics\Tensors\netcore\Common\TensorPrimitives.IAggregationOperator.cs (6)

264(nuint blocks, nuint trailing) = Math.DivRem(remainder, (nuint)Vector128<T>.Count); 446(nuint blocks, nuint trailing) = Math.DivRem(remainder, (nuint)Vector256<T>.Count); 628(nuint blocks, nuint trailing) = Math.DivRem(remainder, (nuint)Vector512<T>.Count); 1403(nuint blocks, nuint trailing) = Math.DivRem(remainder, (nuint)Vector128<T>.Count); 1610(nuint blocks, nuint trailing) = Math.DivRem(remainder, (nuint)Vector256<T>.Count); 1817(nuint blocks, nuint trailing) = Math.DivRem(remainder, (nuint)Vector512<T>.Count);

System\Numerics\Tensors\netcore\Tensor.cs (4)

469span[i] = T.CreateChecked(Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2));

src\libraries\Common\src\System\Collections\Concurrent\SingleProducerSingleConsumerQueue.cs (1)

111int newSegmentSize = Math.Min(_tail._array.Length * 2, MaxSegmentSize);

src\libraries\Common\src\System\Collections\Generic\ArrayBuilder.cs (2)

148nextCapacity = Math.Max(capacity + 1, Array.MaxLength); 151nextCapacity = Math.Max(nextCapacity, minimum);

src\libraries\Common\src\System\Number.Formatting.Common.cs (1)

843int zeroes = Math.Min(-digPos, nMaxDigits);

src\libraries\Common\src\System\Number.Parsing.Common.cs (1)

227numberOfTrailingZeros = Math.Min(numberOfTrailingZeros, numberOfFractionalDigits);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (2)

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

src\libraries\System.Private.CoreLib\src\System\Array.cs (1)

65(uint)Math.Min(newSize, larray.Length));

src\libraries\System.Private.CoreLib\src\System\Buffers\SharedArrayPool.cs (1)

508return Math.Min(partitionCount, Environment.ProcessorCount);

src\libraries\System.Private.CoreLib\src\System\Buffers\StandardFormat.cs (1)

182(div, precision) = Math.DivRem(precision, 10);

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Helper\Base64DecoderHelper.cs (1)

569int BlockSize = Math.Min(source.Length - (int)sourceIndex, 4);

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Number.cs (2)

113int numNonLeadingDigitsBeforeDecimalToCopy = Math.Min(numNonLeadingDigitsBeforeDecimal, maxDigitCount); 177int numDigitsAfterDecimalToCopy = Math.Min(srcIndex - startIndexOfDigitsAfterDecimalToCopy, maxDigitCount - dstIndex);

src\libraries\System.Private.CoreLib\src\System\Byte.cs (4)

279public static (byte Quotient, byte Remainder) DivRem(byte left, byte right) => Math.DivRem(left, right); 525public static byte Clamp(byte value, byte min, byte max) => Math.Clamp(value, min, max); 531public static byte Max(byte x, byte y) => Math.Max(x, y); 537public static byte Min(byte x, byte y) => Math.Min(x, y);

src\libraries\System.Private.CoreLib\src\System\Char.cs (4)

1491static char INumberBase<char>.MaxMagnitude(char x, char y) => (char)Math.Max(x, y); 1494static char INumberBase<char>.MaxMagnitudeNumber(char x, char y) => (char)Math.Max(x, y); 1497static char INumberBase<char>.MinMagnitude(char x, char y) => (char)Math.Min(x, y); 1500static char INumberBase<char>.MinMagnitudeNumber(char x, char y) => (char)Math.Min(x, y);

src\libraries\System.Private.CoreLib\src\System\CodeDom\Compiler\IndentedTextWriter.cs (1)

45set { _indentLevel = Math.Max(value, 0); }

src\libraries\System.Private.CoreLib\src\System\Collections\Concurrent\ConcurrentQueue.cs (2)

97length = (int)Math.Min(BitOperations.RoundUpToPowerOf2((uint)count), MaxSegmentLength); 645int nextSize = tail._preservedForObservation ? InitialSegmentLength : Math.Min(tail.Capacity * 2, MaxSegmentLength);

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\Queue.cs (2)

112int firstPart = Math.Min(_array.Length - _head, numToCopy); 409newcapacity = Math.Max(newcapacity, _array.Length + MinimumGrow);

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ValueListBuilder.cs (3)

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

src\libraries\System.Private.CoreLib\src\System\Collections\HashHelpers.cs (1)

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

src\libraries\System.Private.CoreLib\src\System\Convert.cs (4)

1305return checked((long)Math.Round(value)); 1422return checked((ulong)Math.Round(value)); 2620(uint newLines, uint remainder) = Math.DivRem(outlen, Base64LineBreakPosition); 2992(int quotient, int remainder) = Math.DivRem(source.Length, 2);

src\libraries\System.Private.CoreLib\src\System\DateTime.cs (7)

868if (Math.Abs(value) > maxUnitCount) 873double integralPart = Math.Truncate(value); 1359(uint y100, uint r1) = Math.DivRem(((uint)((dateData & TicksMask) / TicksPer6Hours) | 3U) + 1224, DaysPer400Years); 1360ulong u2 = Math.BigMul(EafMultiplier, r1 | 3U); 1422ulong u2 = Math.BigMul(EafMultiplier, r1 | 3U); 1498ulong u2 = Math.BigMul(EafMultiplier, r1 | 3U); 1556(uint y100, uint r1) = Math.DivRem(((uint)((dateData & TicksMask) / TicksPer6Hours) | 3U), DaysPer400Years);

src\libraries\System.Private.CoreLib\src\System\Decimal.cs (1)

1265public static decimal Clamp(decimal value, decimal min, decimal max) => Math.Clamp(value, min, max);

src\libraries\System.Private.CoreLib\src\System\Decimal.DecCalc.cs (52)

184ulong high = Math.BigMul(a, b, out ulong low); 243(div, rem) = Math.DivRem(tmp, den); 248(div, rem) = Math.DivRem(tmp, den); 256(bufNum.Low64, rem) = Math.DivRem(tmp, den); 409(ulong quo64, bufNum.Low64) = Math.DivRem(num, den); 451ulong prod = Math.BigMul(quo, (uint)den); // quo * lo divisor 496uint prod2 = (uint)Math.BigMul(bufDen.Low64, quo, out prod1); 552ulong hi64 = Math.BigMul(bufNum.Low64, power, out ulong low64); 554hi64 = Math.BigMul(bufNum.U2, power) + hi64; 579ulong hi64 = Math.BigMul(bufNum.Low64, power, out ulong low64); 581bufNum.High64 = Math.BigMul(bufNum.U2, power) + (nuint)hi64; 595bufNum.U2 = (uint)Math.BigMul(bufNum.Low64, power, out ulong low64); 771(quotient, remainder) = Math.DivRem(high, power); 1026low64 = Math.BigMul((uint)low64, UInt32Powers10[scale]); 1030low64 = Math.BigMul((uint)low64, TenToPowerNine); 1039high = (uint)Math.BigMul(low64, power, out low64); 1052tmp64 = Math.BigMul(low64, power, out low64); 1053tmp64 += Math.BigMul(high, power); 1085tmp64 += Math.BigMul(rgulNum[cur], power); 1288ulong high = Math.BigMul(pdecIn.Low64, pwr, out ulong low); 1372ulong tmp = Math.BigMul(low64, power, out low64); 1373tmp += Math.BigMul(high, power); 1416ulong low64 = Math.BigMul(d1.Low, d2.Low); 1429(low64, ulong remainder) = Math.DivRem(low64, power); 1447tmp = Math.BigMul(d1.Low, d2.Low64, out ulong low); 1452tmp += Math.BigMul(d1.Low, d2.High); 1467tmp = Math.BigMul(d1.Low64, d2.Low, out ulong low); 1472tmp += Math.BigMul(d2.Low, d1.High); 1502ulong mid64 = Math.BigMul(d1.Low64, d2.Low64, out tmp); 1508ulong hi64 = Math.BigMul(d1.High, d2.High); 1511hi64 += Math.BigMul(d1.Low64, d2.High, out tmp); 1517hi64 += Math.BigMul(d2.Low64, d1.High, out tmp); 1626mant = (uint)(int)Math.Round(dbl); 1645result.Low64 = Math.BigMul(mant, UInt32Powers10[power]); 1653ulong low64 = Math.BigMul(mant, UInt32Powers10[power - 18]); 1658ulong low64 = Math.BigMul(mant, UInt32Powers10[power - 9]); 1659ulong hi64 = Math.BigMul(TenToPowerNine, low64, out low64); 1681(uint div, uint rem) = Math.DivRem(mant, 10000); 1692(uint div, uint rem) = Math.DivRem(mant, 100); 1703(uint div, uint rem) = Math.DivRem(mant, 10); 1786mant = (ulong)(long)Math.Round(dbl); 1806ulong low64 = Math.BigMul((uint)mant, pow10); 1807ulong hi64 = Math.BigMul((uint)(mant >> 32), pow10); 1967curScale = Math.Min(9, -scale); 2011ulong num = Math.BigMul(remainder, power); 2058curScale = Math.Min(9, -scale); 2120curScale = Math.Min(9, -scale); 2240uint hi32 = (uint)Math.BigMul(d2.Low64, power, out ulong low64); 2322ulong tmp64 = Math.BigMul(b.Buf24.U0, power); 2327tmp64 += Math.BigMul(buf[i], power); 2411(d.uhi, remainder) = Math.DivRem(n, divisor); 2452(d.uhi, remainder) = Math.DivRem(n, power);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\CounterGroup.cs (3)

265_nextPollingTimeStamp += TimeSpan.FromMilliseconds(_pollingIntervalInMilliseconds * Math.Ceiling(delta.TotalMilliseconds / _pollingIntervalInMilliseconds)); 302millisecondsTillNextPoll = Math.Max(1, millisecondsTillNextPoll); 303sleepDurationInMilliseconds = Math.Min(sleepDurationInMilliseconds, millisecondsTillNextPoll);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventCounter.cs (1)

106payload.StandardDeviation = Math.Sqrt(_sumSquared / _count - _sum * _sum / _count / _count);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventSource.cs (4)

2089int paramCount = Math.Min(eventTypes.typeInfos.Length, args.Length); // parameter count mismatch get logged in LogEventArgsMismatches 2150args = new object?[Math.Min(eventDataCount, metadata.Parameters.Length)]; 2945dataDescrs[1].Size = (uint)Math.Min(dataLeft, chunkSize); 3505EventMetadata[] newValues = new EventMetadata[Math.Max(eventData.Length + 16, eventAttribute.EventId + 1)];

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\TraceLogging\NameInfo.cs (1)

26newIdentity = Math.Max(newIdentity, snapshot); // Should be redundant. as we only create descriptors once.

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\TraceLogging\XplatEventLogger.cs (1)

90eventDataCount = Math.Min(payloadName.Count, payload.Count);

src\libraries\System.Private.CoreLib\src\System\Double.cs (58)

src\libraries\System.Private.CoreLib\src\System\Environment.UnixOrBrowser.cs (2)

90ulong userTime100Nanoseconds = Math.Min(cpuInfo.lastRecordedUserTime / 100, (ulong)long.MaxValue); 91ulong kernelTime100Nanoseconds = Math.Min(cpuInfo.lastRecordedKernelTime / 100, (ulong)long.MaxValue);

src\libraries\System.Private.CoreLib\src\System\Globalization\CalendarData.Icu.cs (1)

346occurrences = Math.Max(occurrences, 3);

src\libraries\System.Private.CoreLib\src\System\Globalization\CalendricalCalculationsHelper.cs (16)

36return degree * Math.PI / 180; 41return Math.Sin(RadiansFromDegrees(degree)); 46return Math.Cos(RadiansFromDegrees(degree)); 51return Math.Tan(RadiansFromDegrees(degree)); 66return new DateTime(Math.Min((long)(Math.Floor(numberOfDays) * TimeSpan.TicksPerDay), DateTime.MaxValue.Ticks)).Year; 105double whole = Math.Floor(divisor / dividend); 150return ((Math.Pow(x, 2) / 41048480) - 15) / TimeSpan.SecondsPerDay; 239- (0.5 * Math.Pow(y, 2) * SinOfDegree(4 * lambda)) 240- (1.25 * Math.Pow(eccentricity, 2) * SinOfDegree(2 * anomaly))); 241const double Divisor = 2 * Math.PI; 246return Math.CopySign(Math.Min(Math.Abs(equation), TwelveHours), equation); 365return Math.Min(time, timeSunLastAtLongitude - (MeanSpeedOfSun * longitudeErrorDelta)); 376long lowerBoundNewYearDay = (long)Math.Floor(approx) - 1;

src\libraries\System.Private.CoreLib\src\System\Globalization\CompareInfo.Icu.cs (4)

350int length = Math.Min(source.Length, prefix.Length); 432int length = Math.Min(source.Length, prefix.Length); 534int length = Math.Min(source.Length, suffix.Length); 617int length = Math.Min(source.Length, suffix.Length);

src\libraries\System.Private.CoreLib\src\System\Globalization\CultureData.Icu.cs (1)

87int length = Math.Min(WINDOWS_MAX_COLLATION_NAME_LENGTH, endOfCollation - collationIndex); // Windows doesn't allow collation names longer than 8 characters

src\libraries\System.Private.CoreLib\src\System\Globalization\DateTimeFormat.cs (8)

464FormatDigits(ref result, hour12, Math.Min(tokenLen, 2)); 469FormatDigits(ref result, dateTime.Hour, Math.Min(tokenLen, 2)); 474FormatDigits(ref result, dateTime.Minute, Math.Min(tokenLen, 2)); 479FormatDigits(ref result, dateTime.Second, Math.Min(tokenLen, 2)); 638FormatDigits(ref result, year, Math.Min(tokenLen, 2)); 824(int tens, int ones) = Math.DivRem(offset.Hours, 10); 1502(int offsetHours, int offsetMinutes) = Math.DivRem(offsetTotalMinutes, 60); 1706(int offsetHours, offsetMinutes) = Math.DivRem(offsetMinutes, 60);

src\libraries\System.Private.CoreLib\src\System\Globalization\DateTimeParse.cs (4)

2697if (!time.TryAddTicks((long)Math.Round(raw.fraction * TimeSpan.TicksPerSecond), out time)) 3058if (!time.TryAddTicks((long)Math.Round(partSecond * TimeSpan.TicksPerSecond), out time)) 4761if (!result.parsedDate.TryAddTicks((long)Math.Round(result.fraction * TimeSpan.TicksPerSecond), out result.parsedDate)) 5106if (!dateTime.TryAddTicks((long)Math.Round(fraction * TimeSpan.TicksPerSecond), out result.parsedDate))

src\libraries\System.Private.CoreLib\src\System\Globalization\IdnMapping.Icu.cs (1)

22int estimatedLength = (int)Math.Min(checked(count * 3L + 4), StackallocThreshold);

src\libraries\System.Private.CoreLib\src\System\Globalization\InvariantModeCasing.cs (1)

185int length = Math.Min(lengthA, lengthB);

src\libraries\System.Private.CoreLib\src\System\Globalization\Normalization.Nls.cs (1)

79realLength = Math.Abs(realLength);

src\libraries\System.Private.CoreLib\src\System\Globalization\Ordinal.cs (1)

18int length = Math.Min(lengthA, lengthB);

src\libraries\System.Private.CoreLib\src\System\Globalization\Ordinal.Utf8.cs (6)

23int length = Math.Min(lengthA, lengthB); 111nuint lengthU = Math.Min((uint)lengthA, (uint)lengthB); 176int length = Math.Min(lengthA, lengthB); 336int length = Math.Min(sourceLength, prefixLength); 421nuint lengthU = Math.Min((uint)sourceLength, (uint)prefixLength); 486int length = Math.Min(sourceLength, prefixLength);

src\libraries\System.Private.CoreLib\src\System\Globalization\OrdinalCasing.Icu.cs (1)

191int length = Math.Min(lengthA, lengthB);

src\libraries\System.Private.CoreLib\src\System\Globalization\PersianCalendar.cs (2)

154int y = (int)(Math.Floor(((yearStart - s_persianEpoch) / CalendricalCalculationsHelper.MeanTropicalYearInDays) + 0.5)) + 1; 204year = (int)(Math.Floor(((yearStart - s_persianEpoch) / CalendricalCalculationsHelper.MeanTropicalYearInDays) + 0.5)) + 1;

src\libraries\System.Private.CoreLib\src\System\Globalization\TimeSpanFormat.cs (4)

137(totalSecondsRemaining, fraction64) = Math.DivRem((ulong)ticks, TimeSpan.TicksPerSecond); 181(totalMinutesRemaining, seconds) = Math.DivRem(totalSecondsRemaining, 60 /* seconds per minute */); 189(totalHoursRemaining, minutes) = Math.DivRem(totalMinutesRemaining, 60 /* minutes per hour */); 200(days, hours) = Math.DivRem((uint)totalHoursRemaining, 24 /* hours per day */);

src\libraries\System.Private.CoreLib\src\System\Half.cs (1)

1649Math.ThrowMinMaxException(min, max);

src\libraries\System.Private.CoreLib\src\System\Int16.cs (7)

282public static (short Quotient, short Remainder) DivRem(short left, short right) => Math.DivRem(left, right); 619public static short Clamp(short value, short min, short max) => Math.Clamp(value, min, max); 635Math.ThrowNegateTwosCompOverflow(); 645public static short Max(short x, short y) => Math.Max(x, y); 651public static short Min(short x, short y) => Math.Min(x, y); 657public static int Sign(short value) => Math.Sign(value); 673public static short Abs(short value) => Math.Abs(value);

src\libraries\System.Private.CoreLib\src\System\Int32.cs (8)

54public static long BigMul(int left, int right) => Math.BigMul(left, right); 297public static (int Quotient, int Remainder) DivRem(int left, int right) => Math.DivRem(left, right); 660public static int Clamp(int value, int min, int max) => Math.Clamp(value, min, max); 676Math.ThrowNegateTwosCompOverflow(); 686public static int Max(int x, int y) => Math.Max(x, y); 692public static int Min(int x, int y) => Math.Min(x, y); 698public static int Sign(int value) => Math.Sign(value); 714public static int Abs(int value) => Math.Abs(value);

src\libraries\System.Private.CoreLib\src\System\Int64.cs (8)

54public static Int128 BigMul(long left, long right) => Math.BigMul(left, right); 294public static (long Quotient, long Remainder) DivRem(long left, long right) => Math.DivRem(left, right); 657public static long Clamp(long value, long min, long max) => Math.Clamp(value, min, max); 673Math.ThrowNegateTwosCompOverflow(); 683public static long Max(long x, long y) => Math.Max(x, y); 689public static long Min(long x, long y) => Math.Min(x, y); 695public static int Sign(long value) => Math.Sign(value); 711public static long Abs(long value) => Math.Abs(value);

src\libraries\System.Private.CoreLib\src\System\IntPtr.cs (7)

299public static (nint Quotient, nint Remainder) DivRem(nint left, nint right) => Math.DivRem(left, right); 652public static nint Clamp(nint value, nint min, nint max) => Math.Clamp(value, min, max); 668Math.ThrowNegateTwosCompOverflow(); 678public static nint Max(nint x, nint y) => Math.Max(x, y); 684public static nint Min(nint x, nint y) => Math.Min(x, y); 690public static int Sign(nint value) => Math.Sign(value); 706public static nint Abs(nint value) => Math.Abs(value);

src\libraries\System.Private.CoreLib\src\System\IO\BinaryReader.cs (2)

265int readLength = Math.Min(MaxCharBytesSize, stringLength - currPos); 286sb ??= StringBuilderCache.Acquire(Math.Min(stringLength, StringBuilderCache.MaxBuilderSize)); // Actual string length in chars may be smaller.

src\libraries\System.Private.CoreLib\src\System\IO\BufferedStream.cs (4)

124byte[] shadowBuffer = new byte[Math.Min(_bufferSize + _bufferSize, MaxShadowBufferSize)]; 448int readbytes = Math.Min(_readLen - _readPos, destination.Length); 768int bytesToWrite = Math.Min(_bufferSize - _writePos, count); 783int bytesToWrite = Math.Min(_bufferSize - _writePos, buffer.Length);

src\libraries\System.Private.CoreLib\src\System\IO\File.cs (6)

1230newLength = (uint)Math.Max(Array.MaxLength, rentedArray.Length + 1); 1472newLength = (uint)Math.Max(Array.MaxLength, buffer.Length + 1); 1521int bytesNeeded = checked(preambleSize + encoding.GetMaxByteCount(Math.Min(contents.Length, ChunkSize))); 1539ReadOnlySpan<char> toEncode = contents.Slice(0, Math.Min(contents.Length, ChunkSize)); 1577byte[] bytes = ArrayPool<byte>.Shared.Rent(preambleSize + encoding.GetMaxByteCount(Math.Min(contents.Length, ChunkSize))); 1593ReadOnlyMemory<char> toEncode = contents.Slice(0, Math.Min(contents.Length, ChunkSize));

src\libraries\System.Private.CoreLib\src\System\IO\MemoryStream.cs (3)

137int newCapacity = Math.Max(value, 256); 150newCapacity = Math.Max(value, Array.MaxLength); 357int n = Math.Min(_length - _position, buffer.Length);

src\libraries\System.Private.CoreLib\src\System\IO\Path.cs (1)

908sb.EnsureCapacity(Math.Max(relativeTo.Length, path.Length));

src\libraries\System.Private.CoreLib\src\System\IO\Strategies\BufferedFileStreamStrategy.cs (3)

373int n = Math.Min(_readLen - _readPos, destination.Length); 407bytesFromBuffer = Math.Min(buffer.Length, _readLen - _readPos); 447bytesFromBuffer = Math.Min(_readLen, buffer.Length);

src\libraries\System.Private.CoreLib\src\System\IO\Stream.cs (1)

148bufferSize = (int)Math.Min(bufferSize, remaining);

src\libraries\System.Private.CoreLib\src\System\IO\StreamReader.cs (1)

552int len = Math.Min(_byteLen, preamble.Length);

src\libraries\System.Private.CoreLib\src\System\IO\StreamWriter.cs (2)

438int n = Math.Min(charBuffer.Length - dstPos, count); 789int n = Math.Min(_charLen - _charPos, source.Length - copied);

src\libraries\System.Private.CoreLib\src\System\IO\UnmanagedMemoryStream.cs (1)

371long n = Math.Min(len - pos, buffer.Length);

src\libraries\System.Private.CoreLib\src\System\Math.cs (1)

194return Math.BigMul((ulong)a, (ulong)b, out low);

src\libraries\System.Private.CoreLib\src\System\MathF.cs (4)

49return Math.Abs(x); 248return Math.Max(x, y); 280return Math.Min(x, y); 449return Math.Sign(x);

src\libraries\System.Private.CoreLib\src\System\MemoryExtensions.cs (2)

3531int minLength = Math.Min(span.Length, other.Length); 4884nuint length = Math.Min((nuint)(uint)span.Length, (nuint)(uint)other.Length);

src\libraries\System.Private.CoreLib\src\System\Number.BigInteger.cs (2)

465(uint quotient, uint remainder) = Math.DivRem(lhs._blocks[0], rhs._blocks[0]); 484(digit, carry) = Math.DivRem(value, rhsValue);

src\libraries\System.Private.CoreLib\src\System\Number.Dragon4.cs (1)

177int digitExponent = (int)(Math.Ceiling(((int)(mantissaHighBitIdx) + exponent) * Log10V2 - 0.69));

src\libraries\System.Private.CoreLib\src\System\Number.Formatting.cs (34)

src\libraries\System.Private.CoreLib\src\System\Number.Grisu3.cs (3)

561(digit, integrals) = Math.DivRem(integrals, divisor); 740(digit, integrals) = Math.DivRem(integrals, divisor); 823double k = Math.Ceiling((minExponent + DiyFp.SignificandSize - 1) * D1Log210);

src\libraries\System.Private.CoreLib\src\System\Number.NumberToFloatingPointBits.cs (7)

708uint count = Math.Min(remaining, 9); 849(uint topBlockIndex, uint topBlockBits) = Math.DivRem(integerBitsOfPrecision, 32); 993uint positiveExponent = (uint)(Math.Max(0, number.Scale)); 995uint integerDigitsPresent = Math.Min(positiveExponent, totalDigits); 1006int fastExponent = Math.Abs(exponent); 1395ulong high = Math.BigMul(w, Pow5128Table[index], out ulong low); 1401ulong high2 = Math.BigMul(w, Pow5128Table[index + 1], out ulong _);

src\libraries\System.Private.CoreLib\src\System\Number.Parsing.cs (1)

748value = new decimal(0, 0, 0, sign, (byte)Math.Clamp(-e, 0, 28));

src\libraries\System.Private.CoreLib\src\System\Numerics\INumber.cs (2)

29Math.ThrowMinMaxException(min, max); 50Math.ThrowMinMaxException(min, max);

src\libraries\System.Private.CoreLib\src\System\Random.CompatImpl.cs (1)

279int subtraction = (seed == int.MinValue) ? int.MaxValue : Math.Abs(seed);

src\libraries\System.Private.CoreLib\src\System\Random.ImplBase.cs (2)

61ulong randomProduct = Math.BigMul(maxValue, xoshiro.NextUInt64(), out ulong lowPart); 69randomProduct = Math.BigMul(maxValue, xoshiro.NextUInt64(), out lowPart);

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\DefaultInterpolatedStringHandler.cs (4)

96Math.Max(MinimumArrayPoolLength, literalLength + (formattedCount * GuessedLengthPerHole)); 642uint newCapacity = Math.Max(requiredMinCapacity, Math.Min((uint)_chars.Length * 2, string.MaxLength)); 643int arraySize = (int)Math.Clamp(newCapacity, MinimumArrayPoolLength, int.MaxValue);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\ArrayMarshaller.cs (2)

42int spaceToAllocate = Math.Max(checked(sizeof(TUnmanagedElement) * numElements), 1); 148int spaceToAllocate = Math.Max(bufferSize, 1);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\PointerArrayMarshaller.cs (2)

43int spaceToAllocate = Math.Max(checked(sizeof(TUnmanagedElement) * numElements), 1); 149int spaceToAllocate = Math.Max(bufferSize, 1);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\ReadOnlySpanMarshaller.cs (1)

53int spaceToAllocate = Math.Max(checked(sizeof(TUnmanagedElement) * numElements), 1);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\SpanMarshaller.cs (1)

47int spaceToAllocate = Math.Max(checked(sizeof(TUnmanagedElement) * numElements), 1);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\NativeMemory.Unix.cs (2)

43nuint adjustedAlignment = Math.Max(alignment, (uint)sizeof(void*)); 104nuint adjustedAlignment = Math.Max(alignment, (uint)sizeof(void*));

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Scalar.cs (13)

145return (T)(object)Math.Abs((double)(object)value); 194return (T)(object)Math.Abs((float)(object)value); 266return (T)(object)Math.Ceiling((double)(object)value); 578return (T)(object)Math.Floor((double)(object)value); 1267return (T)(object)Math.Round((double)(object)value); 1475return (T)(object)(double)Math.Sqrt((double)(object)value); 1483return (T)(object)(int)Math.Sqrt((int)(object)value); 1487return (T)(object)(long)Math.Sqrt((long)(object)value); 1491return (T)(object)(nint)Math.Sqrt((nint)(object)value); 1495return (T)(object)(nuint)Math.Sqrt((nuint)(object)value); 1511return (T)(object)(uint)Math.Sqrt((uint)(object)value); 1515return (T)(object)(ulong)Math.Sqrt((ulong)(object)value); 1587return (T)(object)Math.Truncate((double)(object)value);

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector128.cs (2)

322/// <seealso cref="Math.Ceiling(double)" /> 1624/// <seealso cref="Math.Floor(double)" />

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector256.cs (2)

375/// <seealso cref="Math.Ceiling(double)" /> 1730/// <seealso cref="Math.Floor(double)" />

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector512.cs (2)

360/// <seealso cref="Math.Ceiling(double)" /> 1764/// <seealso cref="Math.Floor(double)" />

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector64.cs (2)

328/// <seealso cref="Math.Ceiling(double)" /> 1500/// <seealso cref="Math.Floor(double)" />

src\libraries\System.Private.CoreLib\src\System\Runtime\MemoryFailPoint.cs (2)

153ulong segmentSize = (ulong)(Math.Ceiling((double)size / s_GCSegmentSize) * s_GCSegmentSize); 157ulong requestedSizeRounded = (ulong)(Math.Ceiling((double)sizeInMegabytes / MemoryCheckGranularity) * MemoryCheckGranularity);

src\libraries\System.Private.CoreLib\src\System\SByte.cs (7)

285public static (sbyte Quotient, sbyte Remainder) DivRem(sbyte left, sbyte right) => Math.DivRem(left, right); 582public static sbyte Clamp(sbyte value, sbyte min, sbyte max) => Math.Clamp(value, min, max); 598Math.ThrowNegateTwosCompOverflow(); 608public static sbyte Max(sbyte x, sbyte y) => Math.Max(x, y); 614public static sbyte Min(sbyte x, sbyte y) => Math.Min(x, y); 620public static int Sign(sbyte value) => Math.Sign(value); 636public static sbyte Abs(sbyte value) => Math.Abs(value);

src\libraries\System.Private.CoreLib\src\System\SearchValues\SearchValues.cs (1)

116? new Any1CharPackedIgnoreCaseSearchValues((char)Math.Max(value0, value1))

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\Helpers\AhoCorasickNode.cs (1)

145maxValue = Math.Max(maxValue, childChar);

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\Helpers\RabinKarp.cs (1)

47minimumLength = Math.Min(minimumLength, value.Length);

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\StringSearchValues.cs (1)

459minLength = Math.Min(minLength, value.Length);

src\libraries\System.Private.CoreLib\src\System\Security\SecureString.Unix.cs (1)

19return Math.Max(length, 1) * sizeof(char);

src\libraries\System.Private.CoreLib\src\System\Single.cs (2)

942Math.ThrowMinMaxException(min, max); 952Math.ThrowMinMaxException(min, max);

src\libraries\System.Private.CoreLib\src\System\SpanHelpers.T.cs (1)

1702char lowerCase = (char)Math.Max(char0, char1);

src\libraries\System.Private.CoreLib\src\System\String.Comparison.cs (9)

87int length = Math.Min(strA.Length, strB.Length); 323lengthA = Math.Min(lengthA, strA.Length - indexA); 328lengthB = Math.Min(lengthB, strB.Length - indexB); 358lengthA = Math.Min(lengthA, strA.Length - indexA); 363lengthB = Math.Min(lengthB, strB.Length - indexB); 403int lengthA = Math.Min(length, strA.Length - indexA); 404int lengthB = Math.Min(length, strB.Length - indexB); 484int lengthA = Math.Min(length, strA.Length - indexA); 485int lengthB = Math.Min(length, strB.Length - indexB);

src\libraries\System.Private.CoreLib\src\System\Text\ASCIIEncoding.cs (4)

375int bytesWritten = (int)Ascii.NarrowUtf16ToAscii(pChars, pBytes, (uint)Math.Min(charsLength, bytesLength)); 393int numElementsToConvert = Math.Min(chars.Length, bytes.Length); 666bytesConsumed = (int)Ascii.WidenAsciiToUtf16(pBytes, pChars, (uint)Math.Min(charsLength, bytesLength)); 681int numElementsToConvert = Math.Min(bytes.Length, chars.Length);

src\libraries\System.Private.CoreLib\src\System\Text\CompositeFormat.cs (1)

55argsRequired = Math.Max(argsRequired, segment.ArgIndex + 1);

src\libraries\System.Private.CoreLib\src\System\Text\Latin1Encoding.cs (2)

321int bytesWritten = (int)Latin1Utility.NarrowUtf16ToLatin1(pChars, pBytes, (uint)Math.Min(charsLength, bytesLength)); 621int charsWritten = Math.Min(bytesLength, charsLength);

src\libraries\System.Private.CoreLib\src\System\Text\StringBuilder.cs (17)

135capacity = Math.Max(capacity, length); 159capacity = Math.Min(DefaultCapacity, maxCapacity); 207persistedCapacity = Math.Min(Math.Max(DefaultCapacity, persistedString.Length), persistedMaxCapacity); 417int capacityToPreserve = Math.Min(Capacity, Math.Max(Length * 6 / 5, m_ChunkChars.Length)); 845int length = Math.Min(m_ChunkChars.Length - m_ChunkLength, count); 909chunkEndIndex = Math.Min(chunkEndIndex, chunk.m_ChunkLength); 2109ReadOnlySpan<char> remainingChunk = chunk.m_ChunkChars.AsSpan(indexInChunk, Math.Min(chunk.m_ChunkLength - indexInChunk, count)); 2145Debug.Assert(oldValue.Length > Math.Min(count, chunk.m_ChunkLength - indexInChunk), 2231int curInChunk = Math.Max(startIndexInChunk, 0); 2232int endInChunk = Math.Min(chunk.m_ChunkLength, endIndexInChunk); 2476int lengthToCopy = Math.Min(lengthInChunk, count); 2562int newBlockLength = Math.Max(minBlockCharCount, Math.Min(Length, MaxChunkSize)); 2670StringBuilder newChunk = new StringBuilder(Math.Max(count, DefaultCapacity), chunk.m_MaxCapacity, chunk.m_ChunkPrevious); 2674int copyCount1 = Math.Min(count, indexInChunk);

src\libraries\System.Private.CoreLib\src\System\Text\TranscodingStream.cs (4)

353int bytesToReturn = Math.Min(_readBufferCount, buffer.Length); 432int bytesToReturn = Math.Min(_readBufferCount, buffer.Length); 484int rentalLength = Math.Clamp(buffer.Length, MinWriteRentedArraySize, MaxWriteRentedArraySize); 560int rentalLength = Math.Clamp(remainingOuterEncodedBytes.Length, MinWriteRentedArraySize, MaxWriteRentedArraySize);

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8Utility.Transcoding.cs (4)

32nuint numElementsConverted = Ascii.WidenAsciiToUtf16(pInputBuffer, pOutputBuffer, (uint)Math.Min(inputLength, outputCharsRemaining)); 97uint maxIters = Math.Min(remainingInputBytes, (uint)outputCharsRemaining) / (2 * sizeof(uint)); 853nuint numElementsConverted = Ascii.NarrowUtf16ToAscii(pInputBuffer, pOutputBuffer, (uint)Math.Min(inputLength, outputBytesRemaining)); 943uint minElementsRemaining = (uint)Math.Min(inputCharsRemaining, outputBytesRemaining);

src\libraries\System.Private.CoreLib\src\System\Threading\LowLevelLifoSemaphore.cs (1)

226(int)Math.Min(newCounts.SignalCount, (uint)counts.WaiterCount + counts.SpinnerCount) -

src\libraries\System.Private.CoreLib\src\System\Threading\PortableThreadPool.Blocking.cs (14)

15return Math.Min(_separated.counts.NumThreadsGoal, TargetThreadsGoalForBlockingAdjustment); 28: (short)Math.Min((ushort)(_minThreads + _numBlockedThreads), (ushort)_maxThreads); 146short toSubtract = Math.Min((short)(numThreadsGoal - targetThreadsGoal), _numThreadsAddedDueToBlocking); 157(short)Math.Min((ushort)(_minThreads + BlockingConfig.ThreadsToAddWithoutDelay), (ushort)_maxThreads); 164Math.Max(configuredMaxThreadsWithoutDelay, Math.Min(counts.NumExistingThreads, _maxThreads)); 165short targetThreadsGoalWithoutDelay = Math.Min(targetThreadsGoal, maxThreadsGoalWithoutDelay); 221newNumThreadsGoal = (short)Math.Min(newNumThreadsGoal, achievableNumThreadsGoal); 249return Math.Min((uint)delayStepCount * BlockingConfig.DelayStepMs, BlockingConfig.MaxDelayMs); 327blocking_threadsPerDelayStep_procCountFactor = Math.Max(1, blocking_threadsPerDelayStep_procCountFactor); 337MaxDelayMs = Math.Max(1, Math.Min(MaxDelayMs, GateThread.GateActivitiesPeriodMs)); 338DelayStepMs = Math.Max(1, Math.Min(DelayStepMs, MaxDelayMs));

src\libraries\System.Private.CoreLib\src\System\Threading\PortableThreadPool.cs (6)

191_legacy_minIOCompletionThreads = (short)Math.Max(1, ioCompletionThreads); 193short newMinThreads = (short)Math.Max(1, workerThreads); 274_legacy_maxIOCompletionThreads = (short)Math.Min(ioCompletionThreads, MaxPossibleThreadCount); 276short newMaxThreads = (short)Math.Min(workerThreads, MaxPossibleThreadCount); 313workerThreads = Math.Max(0, _maxThreads - counts.NumProcessingWork); 478_memoryUsageBytes = Math.Min(gcMemoryInfo.MemoryLoadBytes, gcMemoryInfo.HighMemoryLoadThresholdBytes);

src\libraries\System.Private.CoreLib\src\System\Threading\PortableThreadPool.GateThread.cs (1)

319uint nextDelay = Math.Min(nextDelayForGateActivities, nextDelayForBlockingAdjustment);

src\libraries\System.Private.CoreLib\src\System\Threading\PortableThreadPool.HillClimbing.Complex.cs (1)

35public double Abs() => Math.Sqrt(Real * Real + Imaginary * Imaginary);

src\libraries\System.Private.CoreLib\src\System\Threading\PortableThreadPool.HillClimbing.cs (21)

200int sampleCount = ((int)Math.Min(_totalSamples - 1, _samplesToMeasure)) / _wavePeriod * _wavePeriod; 235throughputErrorEstimate = Math.Max(throughputErrorEstimate, (GetWaveComponent(_samples, sampleCount, adjacentPeriod2) / averageThroughput).Abs()); 271double noiseForConfidence = Math.Max(_averageThroughputNoise, throughputErrorEstimate); 288double move = Math.Min(1.0, Math.Max(-1.0, ratio.Real)); 293move *= Math.Min(1.0, Math.Max(0.0, confidence)); 301move = Math.Pow(Math.Abs(move), _gainExponent) * (move >= 0.0 ? 1 : -1) * gain; 302move = Math.Min(move, _maxChangePerSample); 321newThreadWaveMagnitude = Math.Min(newThreadWaveMagnitude, _maxThreadWaveMagnitude); 322newThreadWaveMagnitude = Math.Max(newThreadWaveMagnitude, 1); 332_currentControlSetting = Math.Min(maxThreads - newThreadWaveMagnitude, _currentControlSetting); 333_currentControlSetting = Math.Max(minThreads, _currentControlSetting); 343newThreadCount = Math.Min(maxThreads, newThreadCount); 344newThreadCount = Math.Max(minThreads, newThreadCount); 377newSampleInterval = (int)(0.5 + _currentSampleMs * (10.0 * Math.Min(-ratio.Real, 1.0))); 413entry.lastHistoryCount = (int)(Math.Min(_totalSamples, _samplesToMeasure) / _wavePeriod) * _wavePeriod; 447double w = 2 * Math.PI / period; 448double cos = Math.Cos(w); 457return new Complex(q1 - q2 * cos, q2 * Math.Sin(w)) / numSamples;

src\libraries\System.Private.CoreLib\src\System\Threading\PortableThreadPool.ThreadCounts.cs (3)

43SetInt16Value(Math.Max((short)0, value), NumProcessingWorkShift); 61SetInt16Value(Math.Max((short)0, value), NumExistingThreadsShift); 79SetInt16Value(Math.Max((short)1, value), NumThreadsGoalShift);

src\libraries\System.Private.CoreLib\src\System\Threading\PortableThreadPool.WaitThread.cs (2)

226int handleTimeoutDurationMs = Math.Max(0, registeredWait.TimeoutTimeMs - currentTimeMs); 234timeoutDurationMs = Math.Min(handleTimeoutDurationMs, timeoutDurationMs);

src\libraries\System.Private.CoreLib\src\System\Threading\PortableThreadPool.WorkerThread.cs (3)

218Math.Max( 220Math.Min(newNumExistingThreads, counts.NumThreadsGoal)); 293newNumExistingThreads = Math.Max(numExistingThreads, newNumProcessingWork);

src\libraries\System.Private.CoreLib\src\System\Threading\ProcessorIdCache.cs (3)

101minID = Math.Min(minID, (double)t / iters); 118minTLS = Math.Min(minTLS, (double)t / iters); 143s_processorIdRefreshRate = Math.Min((int)(minID * 5 / minTLS), MaxIdRefreshRate);

src\libraries\System.Private.CoreLib\src\System\Threading\SemaphoreSlim.cs (1)

812int waitersToNotify = Math.Min(currentCount, waitCount) - m_countOfWaitersPulsedToWake;

src\libraries\System.Private.CoreLib\src\System\Threading\ThreadPoolWorkQueue.cs (1)

382return Math.Max(0, m_tailIndex - m_headIndex);

src\libraries\System.Private.CoreLib\src\System\Threading\Timer.cs (1)

125uint actualDuration = Math.Min(requestedDuration, maxPossibleDuration);

src\libraries\System.Private.CoreLib\src\System\Threading\WaitHandle.cs (2)

222safeWaitHandles = new SafeWaitHandle[Math.Max(capacity, 223Math.Min(MaxWaitHandles, 2 * currentLength))];

src\libraries\System.Private.CoreLib\src\System\TimeOnly.cs (1)

132(long days, long newTicks) = Math.DivRem(ticks, TimeSpan.TicksPerDay);

src\libraries\System.Private.CoreLib\src\System\TimeSpan.cs (17)

src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.Unix.cs (2)

1219index += (int)Math.Min(t.IsStdCount, t.TypeCount); 1228index += (int)Math.Min(t.IsGmtCount, t.TypeCount);

src\libraries\System.Private.CoreLib\src\System\UInt16.cs (4)

276public static (ushort Quotient, ushort Remainder) DivRem(ushort left, ushort right) => Math.DivRem(left, right); 544public static ushort Clamp(ushort value, ushort min, ushort max) => Math.Clamp(value, min, max); 550public static ushort Max(ushort x, ushort y) => Math.Max(x, y); 556public static ushort Min(ushort x, ushort y) => Math.Min(x, y);

src\libraries\System.Private.CoreLib\src\System\UInt32.cs (5)

51public static ulong BigMul(uint left, uint right) => Math.BigMul(left, right); 292public static (uint Quotient, uint Remainder) DivRem(uint left, uint right) => Math.DivRem(left, right); 583public static uint Clamp(uint value, uint min, uint max) => Math.Clamp(value, min, max); 589public static uint Max(uint x, uint y) => Math.Max(x, y); 595public static uint Min(uint x, uint y) => Math.Min(x, y);

src\libraries\System.Private.CoreLib\src\System\UInt64.cs (5)

51public static UInt128 BigMul(ulong left, ulong right) => Math.BigMul(left, right); 291public static (ulong Quotient, ulong Remainder) DivRem(ulong left, ulong right) => Math.DivRem(left, right); 582public static ulong Clamp(ulong value, ulong min, ulong max) => Math.Clamp(value, min, max); 588public static ulong Max(ulong x, ulong y) => Math.Max(x, y); 594public static ulong Min(ulong x, ulong y) => Math.Min(x, y);

src\libraries\System.Private.CoreLib\src\System\UIntPtr.cs (4)

295public static (nuint Quotient, nuint Remainder) DivRem(nuint left, nuint right) => Math.DivRem(left, right); 585public static nuint Clamp(nuint value, nuint min, nuint max) => Math.Clamp(value, min, max); 591public static nuint Max(nuint x, nuint y) => Math.Max(x, y); 597public static nuint Min(nuint x, nuint y) => Math.Min(x, y);

src\System\Reflection\Emit\RuntimeILGenerator.cs (3)

90m_ILStream = new byte[Math.Max(size, DefaultSize)]; 261byte[] temp = new byte[Math.Max(m_ILStream.Length * 2, m_length + size)]; 333return (int)Math.Min(ushort.MaxValue, m_maxDepth + m_depthAdjustment);

src\System\RuntimeType.CoreCLR.cs (2)

561newSize = Math.Max(Math.Max(4, 2 * cachedMembers.Length), list.Length);

src\System\StubHelpers.cs (1)

452int numChars = Math.Min(managed.Length, length - 1);

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ValueListBuilder.cs (3)

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

System\Runtime\Serialization\Json\JsonEncodingStreamWrapper.cs (1)

266int size = Math.Min(_chars.Length, buffer.Length);

System\Runtime\Serialization\Json\XmlJsonReader.cs (1)

755actual = Math.Min(count, value.Length);

System\Runtime\Serialization\SchemaExporter.cs (1)

459return isFlags ? (long)Math.Pow(2, index) : index;

System\Runtime\Serialization\XmlReaderDelegator.cs (1)

793return Math.Min(context.RemainingItemCount, dictionaryReader.Quotas.MaxArrayLength);

System\Xml\ArrayHelper.cs (1)

69count = Math.Min(count, 256);

System\Xml\EncodingStreamWrapper.cs (2)

312int max = offset + Math.Min(count, BufferLength); 470int inputCount = Math.Min(count, BufferLength * 2);

System\Xml\ValueHandle.cs (4)

663actual = Math.Min(_length, count); 673int charCount = Math.Min(count / 3 * 4, _length); 742actualByteCount = Math.Min(charCount, byteCount); 807int charCount = Math.Min(count, _length / sizeof(char));

System\Xml\XmlBaseReader.cs (6)

1148actual = Math.Min(count, value.Length); 1178return ReadBytes(DataContractSerializer.Base64Encoding, 3, 4, buffer, offset, Math.Min(count, 512), false); 1370return ReadBytes(DataContractSerializer.Base64Encoding, 3, 4, buffer, offset, Math.Min(count, 512), true); 1390return ReadBytes(DataContractSerializer.BinHexEncoding, 1, 2, buffer, offset, Math.Min(count, 512), true); 1425int actual = Math.Min(_trailByteCount, byteCount); 1493int actual = Math.Min(_trailByteCount, byteCount);

System\Xml\XmlBinaryReader.cs (15)

System\Xml\XmlBinaryReaderSession.cs (3)

43_strings = new XmlDictionaryString[Math.Max(id + 1, 16)]; 47XmlDictionaryString[] newStrings = new XmlDictionaryString[Math.Min(Math.Max(id + 1, _strings.Length * 2), MaxArrayEntries)];

System\Xml\XmlBinaryWriterSession.cs (2)

64IntArray keys = new IntArray(Math.Max(minCount, 16)); 247int[] newArray = new int[Math.Max(index + 1, _array.Length * 2)];

System\Xml\XmlBufferReader.cs (7)

163TryEnsureBytes(Math.Min(count, _windowOffsetMax - offset)); 228byte[] newBuffer = new byte[Math.Max(256, _buffer.Length * 2)]; 230newOffsetMax = Math.Min(newOffsetMax, newBuffer.Length); 284_windowOffsetMax = Math.Max(windowOffset + windowLength, _offsetMax); 872int length = Math.Min(byteLength, charLength); 886int length = Math.Min(byteLength, charLength); 918int length = Math.Min(length1, length2);

System\Xml\XmlCanonicalWriter.cs (3)

346_xmlnsBuffer = new byte[Math.Max(byteCount, 128)]; 350byte[] newBuffer = new byte[Math.Max(_xmlnsOffset + byteCount, _xmlnsBuffer.Length * 2)]; 832int length = Math.Min(length1, length2);

System\Xml\XmlConverter.cs (2)

1071offset += ToCharsD2(Math.Abs(ts.Hours), chars, offset); 1073offset += ToCharsD2(Math.Abs(ts.Minutes), chars, offset);

System\Xml\XmlSigningNodeWriter.cs (1)

360int byteCount = Math.Min(_base64Chars.Length / 4 * 3, count - count % 3);

System\Xml\XmlUTF8TextWriter.cs (2)

654int byteCount = Math.Min(bufferLength / 4 * 3, count - count % 3); 673int byteCount = Math.Min(bufferLength / 4 * 3, count - count % 3);

src\libraries\Common\src\System\Collections\Generic\ArrayBuilder.cs (2)

148nextCapacity = Math.Max(capacity + 1, Array.MaxLength); 151nextCapacity = Math.Max(nextCapacity, minimum);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (2)

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

System\Collections\Generic\ArrayBuilder.cs (2)

30_items = new T[Math.Min(expectedCount, MaxInitialArrayLength)]; 61int newCapacity = Math.Min(_maxCount, 2 * _items.Length);

System\IO\Compression\RunLengthEncoder.cs (1)

68if (!writer.TryWrite((byte)Math.Min(count, 0xFF)) || !writer.TryWrite(value))

System\Text\ValueStringBuilder.cs (3)

30Math.Min(MinimumArrayPoolLength, literalLength + (GuessedLengthPerHole * formattedCount))); 330int newCapacity = (int)Math.Max( 332Math.Min((uint)_chars.Length * 2, ArrayMaxLength));

Windows\Win32\PInvokeCore.GetWindowText.cs (1)

39textLength = Math.Max(textLength, newTextLength);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (2)

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

System\Xml\Core\XmlReader.cs (1)

1712int bytesToRead = Math.Min(bytes.Length, 2);

System\Xml\Core\XmlTextReaderImpl.cs (1)

2885int bytesToRead = Math.Min(4, _ps.bytes.Length - _ps.bytesUsed);

System\Xml\Core\XmlTextReaderImplAsync.cs (1)

913int bytesToRead = Math.Min(4, _ps.bytes.Length - _ps.bytesUsed);

System\Xml\Core\XmlTextWriter.cs (1)

1450_textWriter.Write(_indentChars, 0, Math.Min(i, _indentChars.Length));

System\Xml\Dom\XmlCharacterData.cs (2)

143count = Math.Max(len - offset, 0); 169count = Math.Max(len - offset, 0);

System\Xml\Schema\BitSet.cs (1)

219int i = Math.Min(_bits.Length, other._bits.Length);

System\Xml\Serialization\ReflectionXmlSerializationWriter.cs (2)

1297for (int j = 0; j < Math.Min(pLength, mapping.Members.Length); j++) 1328for (int j = 0; j < Math.Min(pLength, mapping.Members.Length); j++)

System\Xml\Serialization\XmlSerializationReader.cs (2)

482currentSize = Math.Min(currentSize * 2, MAX_ALLOC_SIZE); 503currentSize = Math.Min(block.Length, total);

System\Xml\XmlConvert.cs (1)

1105double temp = Math.Round(value);

System\Xml\XPath\Internal\NumberFunctions.cs (2)

99return Math.Floor((double)_arg.Evaluate(nodeIterator)); 105return Math.Ceiling((double)_arg.Evaluate(nodeIterator));

System\Xml\Xsl\Runtime\NumberFormatter.cs (1)

82Debug.Assert(Math.Pow(totalChars, MaxAlphabeticLength) >= MaxAlphabeticValue);

System\Xml\Xsl\Runtime\XslNumber.cs (2)

308Debug.Assert(val >= 0 && val == Math.Round(val), "ConvertToArabic operates on non-negative integer numbers only"); 314int newLen = Math.Max(oldLen, minLen);

System\Xml\Xsl\Runtime\XsltFunctions.cs (1)

209double temp = Math.Round(value);

System\Xml\Xsl\Runtime\XsltLibrary.cs (3)

39public static readonly MethodInfo Floor = typeof(Math).GetMethod("Floor", new[] { typeof(double) })!; 40public static readonly MethodInfo Ceiling = typeof(Math).GetMethod("Ceiling", new[] { typeof(double) })!; 578idx += Math.Max(count - 4, 0);

System\Xml\Xsl\XPathConvert.cs (4)

745if (wExp2 >= 1023 && wExp2 <= 1075 && dbl == Math.Floor(dbl)) 992Debug.Assert(dblInt == Math.Floor(dblInt) && 1 <= dblInt && dblInt <= 9007199254740991.0d); 1020Debug.Assert(dblInt == Math.Floor(dblInt) && 0 <= dblInt && dblInt < C10toN[iT]); 1042(idx == mantissaSize - 1) && Math.Abs(mantissa[idx] - mantissaPrec[idx]) <= 1

System\Xml\Xsl\XsltOld\NumberAction.cs (1)

122if (Math.Floor(val) == val)

System\Reflection\Emit\ILGeneratorImpl.cs (3)

42_builder = new BlobBuilder(Math.Max(size, DefaultSize)); 49internal int GetMaxStack() => Math.Min(ushort.MaxValue, _maxStackDepth + _depthAdjustment); 277_maxStackDepth = Math.Max(_maxStackDepth, _currentStackDepth);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (2)

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

System\Reflection\Internal\Utilities\MemoryBlock.cs (1)

67displayedBytes = Math.Min(Length, 64);

System\Reflection\Metadata\BlobBuilder.cs (8)

63_buffer = new byte[Math.Max(MinChunkSize, capacity)]; 68return new BlobBuilder(Math.Max(_buffer.Length, minimalSize)); 236int minLength = Math.Min(left.Length - leftStart, right.Length - rightStart); 287int bytesToCopy = Math.Min(bufferEnd, chunkEnd) - bufferStart; 534var newChunk = AllocateChunk(Math.Max(newLength, MinChunkSize)); 634int bytesToCurrent = Math.Min(FreeBytes, byteCount); 674int bytesToCurrent = Math.Min(FreeBytes, buffer.Length); 712int bytesToCurrent = Math.Min(FreeBytes, byteCount);

System\Reflection\Metadata\Ecma335\Encoding\ControlFlowBuilder.cs (2)

30internal int OperandSize => Math.Min(_instructionEndDisplacement, 4); 303int chunkSize = Math.Min(branch.OperandOffset - srcOffset, srcBlob.Length - srcBlobOffset);

System\Reflection\Metadata\Ecma335\MetadataBuilder.Heaps.cs (3)

24return new HeapBlobBuilder(Math.Max(Math.Max(minimalSize, ChunkCapacity), _capacityExpansion)); 29_capacityExpansion = Math.Max(0, capacity - Count - FreeBytes);

System\Reflection\PortableExecutable\PEBuilder.cs (2)

446length = Math.Min(remainingHeaderToSign, blobLength); 452length = Math.Min(remainingHeader, blobLength);

System\Reflection\PortableExecutable\PEReader.cs (1)

414int size = Math.Min(

System\Reflection\TypeLoading\General\HashHelpers.cs (1)

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

artifacts\obj\System.Runtime\Debug\net10.0\System.Runtime.Forwards.cs (1)

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

System\Runtime\Caching\CacheExpires.cs (3)

142return Math.Max(0, (int)((utcExpires - _utcLastCountReset).Ticks / s_COUNT_INTERVAL.Ticks)); 390newLength = Math.Max(oldLength + MIN_PAGES_INCREMENT, newLength); 391newLength = Math.Min(newLength, oldLength + MAX_PAGES_INCREMENT);

System\Runtime\Caching\CacheMemoryMonitor.cs (2)

119memoryLimit = Math.Min(usableMemory, recommendedPrivateByteLimit); 215percent = Math.Min(100, (int)((cacheSize - _memoryLimit) * 100L / cacheSize));

System\Runtime\Caching\CacheUsage.cs (4)

28Debug.Assert((Math.Abs(entryIndex) & ENTRY_MASK) == (Math.Abs(entryIndex)), "(Math.Abs(entryIndex) & ENTRY_MASK) == Math.Abs(entryIndex)"); 375newLength = Math.Max(oldLength + MIN_PAGES_INCREMENT, newLength); 376newLength = Math.Min(newLength, oldLength + MAX_PAGES_INCREMENT);

System\Runtime\Caching\MemoryCacheStatistics.cs (3)

82int newPollingInterval = Math.Min(_configPollingInterval, MEMORYSTATUS_INTERVAL_30_SECONDS); 117return Math.Max(_physicalMemoryMonitor.GetPercentToTrim(_lastTrimTime, _lastTrimPercent), _cacheMemoryMonitor.GetPercentToTrim(_lastTrimTime, _lastTrimPercent)); 286int percent = Math.Max(minPercent, GetPercentToTrim());

System\Runtime\Caching\MemoryCacheStore.cs (1)

383toTrim = (int)Math.Ceiling(((long)count * (long)percent) / 100D);

System\Runtime\Caching\PhysicalMemoryMonitor.cs (4)

89percent = Math.Min(50, (int)((lastTrimPercent * TargetTotalMemoryTrimIntervalTicks) / ticksSinceTrim)); 90percent = Math.Max(MinTotalMemoryTrimPercent, percent); 108_pressureHigh = Math.Max(3, physicalMemoryLimitPercentage); 109_pressureLow = Math.Max(1, _pressureHigh - 9);

System\Runtime\Caching\PhysicalMemoryMonitor.Unix.cs (1)

45return Math.Max(1, memoryLoad);

System.Runtime.Extensions.cs (1)

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

src\libraries\Common\src\System\Number.Formatting.Common.cs (2)

134(value, uint remainder) = Math.DivRem(value, 10); 843int zeroes = Math.Min(-digPos, nMaxDigits);

src\libraries\Common\src\System\Number.Parsing.Common.cs (1)

227numberOfTrailingZeros = Math.Min(numberOfTrailingZeros, numberOfFractionalDigits);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (2)

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

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ValueListBuilder.cs (3)

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

System\Number.BigInteger.cs (9)

326ReadOnlySpan<byte> intDigits = number.Digits.Slice(0, Math.Min(number.Scale, number.DigitsCount)); 381int totalDigitCount = Math.Min(number.DigitsCount, number.Scale); 406int powersOf1e9BufferLength = PowersOf1e9.GetBufferSize(Math.Max(valueDigits, trailingZeroCount + 1), out int maxIndex); 501int trailingPartialCount = Math.DivRem(trailingZeroCount, PowersOf1e9.MaxPartialDigits, out int remainingTrailingZeroCount); 665int charsIncludeDigits = Math.Max(digits, charsForBits); 809(ulong quo, ulong rem) = Math.DivRem(uuRes, TenPowMaxPartial); 815(uCarry, base1E9Buffer[cuDst++]) = Math.DivRem(uCarry, TenPowMaxPartial); 829int strDigits = Math.Max(digits, valueDigits); 1129int trailingPartialCount = Math.DivRem(trailingZeroCount, MaxPartialDigits, out int remainingTrailingZeroCount);

System\Numerics\BigInteger.cs (20)

364int wholeUInt32Count = Math.DivRem(byteCount, 4, out int unalignedBytes); 757(quotient, remainder) = Math.DivRem(dividend._sign, divisor._sign); 839return Log(value, Math.E); 851return Math.Log(value._sign, baseValue); 866return Math.Log(x, baseValue) + (b - 64) / Math.Log(baseValue, 2); 1611double significand = (double)highBits * Math.Pow(10, exponentLow - exponent); 1614double log10 = Math.Log10(significand); 1618significand /= Math.Pow(10, Math.Floor(log10)); 1623significand = Math.Round(significand, 8); 2361size = Math.Max(x.Length, y.Length); 2417size = Math.Max(x.Length, y.Length); 2468size = Math.Max(x.Length, y.Length); 2505(int digitShift, int smallShift) = Math.DivRem(shift, kcbitUint); 2564(int digitShift, int smallShift) = Math.DivRem(shift, kcbitUint); 2597int zl = Math.Max(xl - digitShift, 0) + (trackSignBit ? 1 : 0); 3276(int digitShift, int smallShift) = Math.DivRem(rotateAmount, kcbitUint); 3431(int digitShift, int smallShift) = Math.DivRem(rotateAmount, kcbitUint); 5270(int digitShift, int smallShift) = Math.DivRem(shiftAmount, kcbitUint);

System\Numerics\BigIntegerCalculator.DivRem.cs (2)

434int t = Math.Max(2, (a.Length + n - 1) / n); // Max(2, Ceil(a.Length/n)) 571int quotientLength = Math.Min(left.Length - right.Length + 1, quotient.Length);

System\Numerics\BigIntegerCalculator.PowMod.cs (2)

218int size = Math.Max(value.Length, bits.Length); 266int size = Math.Max(value.Length, bits.Length);

System\Numerics\Complex.cs (51)

42private static readonly double s_sqrtRescaleThreshold = double.MaxValue / (Math.Sqrt(2.0) + 1.0); 45private static readonly double s_asinOverflowThreshold = Math.Sqrt(double.MaxValue) / 2.0; 48private static readonly double s_log2 = Math.Log(2.0); 64public double Phase { get { return Math.Atan2(m_imaginary, m_real); } } 68(double sin, double cos) = Math.SinCos(phase); 229if (Math.Abs(d) < Math.Abs(c)) 278if (Math.Abs(d) < Math.Abs(c)) 312return x * Math.Log(xp1) / (xp1 - 1.0); 316return Math.Log(xp1); 379(double sin, double cos) = Math.SinCos(value.m_real); 380return new Complex(sin * Math.Cosh(value.m_imaginary), cos * Math.Sinh(value.m_imaginary)); 397Asin_Internal(Math.Abs(value.Real), Math.Abs(value.Imaginary), out b, out bPrime, out v); 402u = Math.Asin(b); 406u = Math.Atan(bPrime); 417(double sin, double cos) = Math.SinCos(value.m_real); 418return new Complex(cos * Math.Cosh(value.m_imaginary), -sin * Math.Sinh(value.m_imaginary)); 430Asin_Internal(Math.Abs(value.Real), Math.Abs(value.Imaginary), out b, out bPrime, out v); 435u = Math.Acos(b); 439u = Math.Atan(1.0 / bPrime); 442if (value.Real < 0.0) u = Math.PI - u; 461(double sin, double cos) = Math.SinCos(x2); 462double cosh = Math.Cosh(y2); 463if (Math.Abs(value.m_imaginary) <= 4.0) 466return new Complex(sin / D, Math.Sinh(y2) / D); 471return new Complex(sin / cosh / D, Math.Tanh(y2) / D); 550v = s_log2 + Math.Log(big) + 0.5 * Log1P(ratio * ratio); 565bPrime = x / Math.Sqrt((a + x) * amx); 573bPrime = x / y / Math.Sqrt((a + x) * t); 590v = Log1P(am1 + y * Math.Sqrt(t * (a + 1.0))); 595v = Log1P(am1 + Math.Sqrt(am1 * (a + 1.0))); 601v = Math.Log(a + Math.Sqrt((a - 1.0) * (a + 1.0))); 614return new Complex(Math.Log(Abs(value)), Math.Atan2(value.m_imaginary, value.m_real)); 630double expReal = Math.Exp(value.m_real); 664return new Complex(0.0, Math.Sqrt(-value.m_real)); 667return new Complex(Math.Sqrt(value.m_real), 0.0); 699if ((Math.Abs(realCopy) >= s_sqrtRescaleThreshold) || (Math.Abs(imaginaryCopy) >= s_sqrtRescaleThreshold)) 717x = Math.Sqrt((double.Hypot(realCopy, imaginaryCopy) + realCopy) * 0.5); 722y = Math.Sqrt((double.Hypot(realCopy, imaginaryCopy) - realCopy) * 0.5); 754double theta = Math.Atan2(valueImaginary, valueReal); 755double newRho = powerReal * theta + powerImaginary * Math.Log(rho); 757double t = Math.Pow(rho, powerReal) * Math.Exp(-powerImaginary * theta);

src\libraries\System.Private.CoreLib\src\System\Collections\HashHelpers.cs (1)

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

System\Runtime\Serialization\FormatterServices.cs (1)

157Array.Resize(ref parentTypes, Math.Max(parentTypeCount * 2, 12));

System\Runtime\Serialization\Schema\CodeExporter.cs (1)

1545length = Math.Min(MaxIdentifierLength, length);

src\libraries\Common\src\System\IO\MemoryMappedFiles\MemoryMappedFileMemoryManager.cs (1)

42int length = (int)Math.Min(int.MaxValue, fileStream.Length);

src\libraries\Common\src\System\Security\Cryptography\ECDiffieHellmanDerivation.cs (1)

223int len = Math.Min(p.Length, retSpan.Length);

src\libraries\Common\src\System\Security\Cryptography\Pkcs\Pkcs12Builder.cs (1)

198salt = stackalloc byte[Math.Min(macKey.Length, 128)];

src\libraries\Common\src\System\Security\Cryptography\Pkcs12Kdf.cs (1)

288Span<byte> nullTerminator = destination.Slice(0, Math.Min(2, destination.Length));

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (2)

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

System\Security\Cryptography\Base64Transforms.cs (2)

33int inputBlocks = Math.DivRem(inputCount, InputBlockSize, out int inputRemainder); 71int inputBlocks = Math.DivRem(inputCount, InputBlockSize, out int inputRemainder);

System\Security\Cryptography\CryptoStream.cs (1)

315int bytesToCopy = Math.Min(_outputBufferIndex, buffer.Length);

System\Security\Cryptography\LiteHashProvider.cs (2)

125maxRead = Math.Max(maxRead, read); 156maxRead = Math.Max(maxRead, read);

System\Security\Cryptography\LiteHashProvider.Xof.cs (1)

141maxRead = Math.Max(maxRead, read);

System\Security\Cryptography\PemEncoding.cs (1)

401int lineCount = Math.DivRem(encodedDataLength, EncodedLineLength, out int remainder);

System\Security\Cryptography\PKCS1MaskGenerationMethod.cs (1)

49Buffer.BlockCopy(hash, 0, rgbT, ib, Math.Min(rgbT.Length - ib, hash.Length));

System\Security\Cryptography\RandomNumberGenerator.cs (2)

319Span<byte> remainingRandom = randomBuffer.Slice(0, Math.Min(RandomBufferSize, needed)); 339remainingRandom = randomBuffer.Slice(0, Math.Min(RandomBufferSize, needed));

System\Security\Cryptography\SymmetricAlgorithm.cs (2)

372int wholeBlocks = Math.DivRem(plaintextLength, blockSizeBytes, out int remainder) * blockSizeBytes; 451int feedbackAligned = Math.DivRem(plaintextLength, feedbackSizeInBytes, out int remainder) * feedbackSizeInBytes;

System\Security\Cryptography\SymmetricPadding.cs (1)

16int wholeBlocks = Math.DivRem(plaintextLength, paddingSizeInBytes, out int remainder) * paddingSizeInBytes;

System\Security\Cryptography\X509Certificates\CertificatePolicy.cs (1)

222restriction = Math.Min(restriction, policyRestriction.Value);

System\Security\Cryptography\X509Certificates\OpenSslX509ChainProcessor.cs (3)

1381int size = Math.Max(DefaultChainCapacity, errorDepth + 1); 1399LastError = Math.Max(errorDepth, LastError); 1566bucket = Math.DivRem(val, 32, out int localBitNumber);

System\Security\Cryptography\XmlKeyHelper.cs (2)

81int idx = Math.Max(0, buf.Length - sizeof(int)); 144int localLength = Math.Min(ByteLimit, length);

System\Security\Cryptography\Cose\CoseMultiSignMessage.cs (2)

773byte[] buffer = ArrayPool<byte>.Shared.Rent(Math.Max(toBeSignedLength, CoseHelpers.ComputeSignatureSize(signer))); 846byte[] buffer = ArrayPool<byte>.Shared.Rent(Math.Max(toBeSignedLength, CoseHelpers.ComputeSignatureSize(signer)));

src\libraries\Common\src\System\Security\Cryptography\Pkcs\Pkcs12Builder.cs (1)

198salt = stackalloc byte[Math.Min(macKey.Length, 128)];

src\libraries\Common\src\System\Security\Cryptography\Pkcs12Kdf.cs (1)

288Span<byte> nullTerminator = destination.Slice(0, Math.Min(2, destination.Length));

System\Security\Cryptography\Pkcs\Asn1\Rfc3161Accuracy.manual.cs (2)

19long totalMillis = Math.DivRem(accuracyInMicroseconds, 1000, out long micros); 20long seconds = Math.DivRem(totalMillis, 1000, out long millis);

System\ServiceModel\Federation\WSTrustChannelSecurityTokenProvider.cs (1)

356DateTime effectiveExpiration = AddTicks(fromTime, Math.Min(effectiveInterval, WSTrustTokenParameters.MaxIssuedTokenCachingTime.Ticks));

System\ServiceModel\Channels\Connection.cs (1)

72int bytesToCopy = Math.Min(buffer.Length, _preReadData.Length);

System\ServiceModel\Channels\FramingChannels.cs (2)

382Math.Min(FaultStringDecoder.FaultSizeQuota, connection.ConnectionBufferSize)), 408Math.Min(FaultStringDecoder.FaultSizeQuota, connection.ConnectionBufferSize)),

System\ServiceModel\Channels\SingletonConnectionReader.cs (8)

351int bytesToCopy = Math.Min(_chunkBytesRemaining, 352Math.Min(_chunkBufferSize, count)); 377bytesToRead = Math.Min(count, _chunkBytesRemaining + IntEncoder.MaxEncodedSize); 383DecodeData(buffer, offset, Math.Min(bytesRead, _chunkBytesRemaining)); 455int bytesToCopy = Math.Min(_chunkBytesRemaining, 456Math.Min(_chunkBufferSize, count)); 481bytesToRead = Math.Min(count, _chunkBytesRemaining + IntEncoder.MaxEncodedSize); 487DecodeData(buffer, offset, Math.Min(bytesRead, _chunkBytesRemaining));

System\Runtime\BackoffTimeoutHelper.cs (1)

72return Ticks.ToTimeSpan(Math.Max(

System\ServiceModel\XmlBuffer.cs (1)

48int initialBufferSize = Math.Min(512, maxBufferSize);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (2)

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

System\Text\Encodings\Web\TextEncoder.cs (4)

161int minBufferBumpEachIteration = Math.Max(MaxOutputCharactersPerInputCharacter, EncodeStartingOutputBufferSize); 166Span<char> destBuffer = stringBuilder.AppendSpan(Math.Max(remainingInput.Length, minBufferBumpEachIteration)); 520int minBufferBumpEachIteration = Math.Max(MaxOutputCharactersPerInputCharacter, EncodeStartingOutputBufferSize); 521char[] rentedArray = ArrayPool<char>.Shared.Rent(Math.Max(value.Length, minBufferBumpEachIteration));

src\libraries\Common\src\System\Net\ArrayBuffer.cs (2)

161int newSize = Math.Max(desiredSize, (int)Math.Min(ArrayMaxLength, 2 * (uint)_bytes.Length));

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (2)

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

src\libraries\System.Text.Json\Common\JsonHelpers.cs (1)

117var adjacencyRow = new bool[Math.Max(nodes.Count, count)];

System\Text\Json\BitStack.cs (1)

168int nextDouble = Math.Max(minSize + 1, _array.Length * 2);

System\Text\Json\Document\JsonDocument.Parse.cs (2)

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

System\Text\Json\JsonHelpers.Date.cs (1)

308int fractionEnd = Math.Min(sourceIndex + JsonConstants.DateTimeParseNumFractionDigits, source.Length);

System\Text\Json\Reader\Utf8JsonReader.MultiSegment.cs (4)

551int amountToWrite = Math.Min(span.Length, (int)_bytePositionInLine + 1); 561int amountToWrite = Math.Min(span.Length, (int)_bytePositionInLine + 1); 588int amountToWrite = Math.Min(span.Length, readSoFar.Length - written); 608amountToWrite = Math.Min(span.Length, (int)_bytePositionInLine + 1);

System\Text\Json\Serialization\Converters\Object\ObjectWithParameterizedConstructorConverter.cs (2)

350ArrayPool<FoundProperty>.Shared.Rent(Math.Max(1, state.Current.JsonTypeInfo.PropertyCache.Length)); 546argumentState.FoundPropertiesAsync = ArrayPool<FoundPropertyAsync>.Shared.Rent(Math.Max(1, state.Current.JsonTypeInfo.PropertyCache.Length));

System\Text\Json\Serialization\Metadata\JsonTypeInfo.Cache.cs (1)

97int iForward = Math.Min(propertyIndex, count);

System\Text\Json\Serialization\ReadBufferState.cs (1)

46_buffer = ArrayPool<byte>.Shared.Rent(Math.Max(initialBufferSize, JsonConstants.Utf8Bom.Length));

System\Text\Json\Serialization\WriteStack.cs (2)

317int stackSize = Math.Max(_count, _continuationCount); 355int stackSize = Math.Max(_count, _continuationCount);

System\Text\Json\ThrowHelper.cs (1)

534int printFirst10 = Math.Min(value.Length, 10);

System\Text\Json\Writer\Utf8JsonWriter.cs (2)

1169int sizeHint = Math.Max(DefaultGrowthSize, requiredSize); 1206int sizeHint = Math.Max(InitialGrowthSize, requiredSize);

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ValueListBuilder.cs (3)

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

src\libraries\System.Text.Json\Common\JsonHelpers.cs (1)

117var adjacencyRow = new bool[Math.Max(nodes.Count, count)];

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (2)

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

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ValueListBuilder.cs (3)

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

System\Text\RegularExpressions\Regex.EnumerateSplits.cs (1)

233int start = _lastMatch.Index + Math.Max(_lastMatch.Length, 0);

System\Text\RegularExpressions\RegexCompiler.cs (3)

103private static MethodInfo MathMinIntIntMethod => field ??= typeof(Math).GetMethod("Min", [typeof(int), typeof(int)])!; 849int setsToUse = Math.Min(sets.Count, MaxSets); 1093maxDistance = Math.Max(maxDistance, sets[i].Distance);

System\Text\RegularExpressions\RegexFindOptimizations.cs (2)

33positiveLookaheadOpts.MinRequiredLength = Math.Max(opts.MinRequiredLength, positiveLookaheadOpts.MinRequiredLength); 745int endMinusRequiredLength = textSpan.Length - Math.Max(1, MinRequiredLength);

System\Text\RegularExpressions\RegexInterpreterCode.cs (1)

234string Indent() => new string(' ', Math.Max(1, 25 - sb.Length));

System\Text\RegularExpressions\RegexNode.cs (8)

1283int minLength = Math.Min(startingSpan.Length, startingNode.Str.Length); 2291return (int)Math.Min(int.MaxValue - 1, (long)M * Child(0).ComputeMinLength()); 2301min = Math.Min(min, Child(i).ComputeMinLength()); 2308return Math.Min(Child(0).ComputeMinLength(), Child(1).ComputeMinLength()); 2312return Math.Min(Child(1).ComputeMinLength(), Child(2).ComputeMinLength()); 2323return (int)Math.Min(int.MaxValue - 1, sum); 2427maxLength = Math.Max(maxLength, next); 2439Math.Max(yes, no) :

System\Text\RegularExpressions\RegexParser.cs (1)

1436int c = Math.Min(3, _pattern.Length - _pos);

System\Text\RegularExpressions\RegexPrefixAnalyzer.cs (9)

114int reps = node.Kind is RegexNodeKind.One ? 1 : Math.Min(node.M, MaxPrefixLength); 164int reps = node.Kind is RegexNodeKind.Set ? 1 : Math.Min(node.M, MaxPrefixLength); 228int limit = Math.Min(node.M, MaxPrefixLength); // MaxPrefixLength here is somewhat arbitrary, as a single loop iteration could yield multiple chars 434int count = Math.Min(node.M, SingleCharIterationLimit); 442int limit = Math.Min(node.M, NodeIterationLimit); 612int minIterations = Math.Min(node.M, MaxLoopExpansion); 643int minIterations = Math.Min(node.M, MaxLoopExpansion); 856int c = Math.Max(s1CharsLength, s1RangeLength).CompareTo(Math.Max(s2CharsLength, s2RangeLength));

System\Text\RegularExpressions\Symbolic\BDD.cs (1)

316m = Math.Max(serialized[i], m);

System\Text\RegularExpressions\Symbolic\BitVector.cs (2)

74(int block, int bit) = Math.DivRem(i, 64); 82(int block, int bit) = Math.DivRem(i, 64);

System\Text\RegularExpressions\Symbolic\MintermClassifier.cs (1)

61maxChar = Math.Max(maxChar, (int)ranges[^1].Item2);

System\Text\RegularExpressions\Symbolic\RegexNodeConverter.cs (2)

400BDD cond = MapCategoryCodeToCondition((UnicodeCategory)(Math.Abs(categoryCode) - 1)); 427int cat = Math.Abs((int)categoryCode) - 1;

System\Text\RegularExpressions\Symbolic\SparseIntMap.cs (1)

79newLength = Math.Max(2 * _sparse.Length, newLength);

System\Text\RegularExpressions\Symbolic\SymbolicRegexMatcher.Automata.cs (1)

321int newsize = Math.Max(_nfaCoreIdArray.Length * 2, InitialNfaStateCapacity);

System\Text\RegularExpressions\Symbolic\SymbolicRegexNode.cs (2)

2333return (int)Math.Min((long)m + n, int.MaxValue); 2340return (int)Math.Min((long)m * n, int.MaxValue);

RegexGenerator.Emitter.cs (2)

1143int setsToUse = Math.Min(sets.Count, MaxSets); 1253maxDistance = Math.Max(maxDistance, sets[i].Distance);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (2)

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

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ValueListBuilder.cs (3)

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

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexFindOptimizations.cs (1)

33positiveLookaheadOpts.MinRequiredLength = Math.Max(opts.MinRequiredLength, positiveLookaheadOpts.MinRequiredLength);

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexNode.cs (8)

1283int minLength = Math.Min(startingSpan.Length, startingNode.Str.Length); 2291return (int)Math.Min(int.MaxValue - 1, (long)M * Child(0).ComputeMinLength()); 2301min = Math.Min(min, Child(i).ComputeMinLength()); 2308return Math.Min(Child(0).ComputeMinLength(), Child(1).ComputeMinLength()); 2312return Math.Min(Child(1).ComputeMinLength(), Child(2).ComputeMinLength()); 2323return (int)Math.Min(int.MaxValue - 1, sum); 2427maxLength = Math.Max(maxLength, next); 2439Math.Max(yes, no) :

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexParser.cs (1)

1436int c = Math.Min(3, _pattern.Length - _pos);

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexPrefixAnalyzer.cs (9)

114int reps = node.Kind is RegexNodeKind.One ? 1 : Math.Min(node.M, MaxPrefixLength); 164int reps = node.Kind is RegexNodeKind.Set ? 1 : Math.Min(node.M, MaxPrefixLength); 228int limit = Math.Min(node.M, MaxPrefixLength); // MaxPrefixLength here is somewhat arbitrary, as a single loop iteration could yield multiple chars 434int count = Math.Min(node.M, SingleCharIterationLimit); 442int limit = Math.Min(node.M, NodeIterationLimit); 612int minIterations = Math.Min(node.M, MaxLoopExpansion); 643int minIterations = Math.Min(node.M, MaxLoopExpansion); 856int c = Math.Max(s1CharsLength, s1RangeLength).CompareTo(Math.Max(s2CharsLength, s2RangeLength));

Stubs.cs (1)

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

System\Threading\Barrier.cs (2)

874int waitTime = totalTimeout == Timeout.Infinite ? maxWait : Math.Min(maxWait, totalTimeout); 888maxWait = maxWait >= waitTimeCeiling ? waitTimeCeiling : Math.Min(maxWait << 1, waitTimeCeiling);

src\libraries\Common\src\System\Collections\Concurrent\SingleProducerSingleConsumerQueue.cs (1)

111int newSegmentSize = Math.Min(_tail._array.Length * 2, MaxSegmentSize);

System\Threading\RateLimiting\FixedWindowRateLimiter.cs (1)

213int replenishWindow = Math.Max(replenishAmount / _options.PermitLimit, 1);

System\Threading\RateLimiting\TokenBucketRateLimiter.cs (2)

220int replenishPeriods = Math.Max(replenishAmount / _options.TokensPerPeriod, 1); 314_tokenCount = Math.Min(_options.TokenLimit, _tokenCount + add);

src\libraries\Common\src\System\Collections\Concurrent\SingleProducerSingleConsumerQueue.cs (1)

111int newSegmentSize = Math.Min(_tail._array.Length * 2, MaxSegmentSize);

System\Threading\Tasks\Parallel.cs (1)

116rval = (rval == -1) ? schedulerMax : Math.Min(schedulerMax, rval);

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (2)

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

Microsoft\Windows\Controls\KeyTipAdorner.cs (2)

309if (DoubleUtil.LessThan(Math.Abs(keyTipTopY), RibbonGroupKeyTipAxisNudgeSpace)) 314else if (DoubleUtil.LessThan(Math.Abs(itemsPresenter.ActualHeight - keyTipBottomY), RibbonGroupKeyTipAxisNudgeSpace))

Microsoft\Windows\Controls\Ribbon\NativeMethods.cs (1)

593handleCount = Math.Max(0, handleCount);

Microsoft\Windows\Controls\Ribbon\Primitives\RibbonContextualTabGroupsPanel.cs (5)

71if (Math.Abs(tabGroupHeader.TabsDesiredWidth - remainingSpace) > _desiredWidthEpsilon) 74width = Math.Min(tabGroupHeader.TabsDesiredWidth, remainingSpace); 87desiredSize.Height = Math.Max(desiredSize.Height, tabGroupHeader.DesiredSize.Height); 104double width = Math.Max(tabGroupHeader.ArrangeWidth,0); 109tabGroupHeader.Arrange(new Rect(startX, y, width, Math.Max(0.0, height - 1)));

Microsoft\Windows\Controls\Ribbon\Primitives\RibbonGalleryCategoriesPanel.cs (10)

386maxChildWidth = Math.Max(maxChildWidth, childSize.Width); 387maxChildHeight = Math.Max(maxChildHeight, childSize.Height); 461stackDesiredSize.Width = Math.Max(stackDesiredSize.Width, childDesiredSize.Width); 471stackDesiredSize.Width = Math.Min(stackDesiredSize.Width, constraint.Width); 472stackDesiredSize.Height = Math.Min(stackDesiredSize.Height, constraint.Height); 491logicalVisibleSpace = DoubleUtil.LessThanOrClose((viewportOffsetY + logicalVisibleSpace) - stackDesiredSize.Height, 0.0) ? 0.0 : Math.Min((viewportOffsetY + logicalVisibleSpace) - stackDesiredSize.Height, constraint.Height); 492viewportOffsetY = Math.Max(viewportOffsetY - logicalVisibleSpace, 0.0); 495offset.X = Math.Max(0, Math.Min(offset.X, extent.Width - viewport.Width)); 601rcChild.Width = Math.Max(finalSize.Width, child.DesiredSize.Width);

Microsoft\Windows\Controls\Ribbon\Primitives\RibbonGalleryItemsPanel.cs (25)

340maxColumnWidth = Math.Max(maxColumnWidth, childSize.Width); 341maxItemHeight = Math.Max(maxItemHeight, childSize.Height); 362columnCount = Math.Min(Math.Max(minColumnCount, Math.Min((int)(availableSize.Width / maxColumnWidth), childrenCount)), maxColumnCount); 374columnCount = Math.Min(Math.Max(minColumnCount, Math.Min((int)(availableSize.Width / maxColumnWidth), childrenCount)), maxColumnCount); 375arrangeWidth = Math.Max(availableSize.Width / columnCount, maxColumnWidth); 381columnCount = Math.Min(Math.Max(minColumnCount, Math.Min((int)(availableSize.Width / arrangeWidth), childrenCount)), maxColumnCount); 390columnCount = Math.Min(Math.Max(minColumnCount, Math.Min((int)(availableSize.Width / maxColumnWidth), childrenCount)), maxColumnCount); 391_arrangeWidth = Math.Max(availableSize.Width / columnCount, maxColumnWidth); 397columnCount = Math.Min(Math.Max(minColumnCount, Math.Min((int)(availableSize.Width / _arrangeWidth), childrenCount)), maxColumnCount); 404columnCount = Math.Max(minColumnCount, Math.Min(childrenCount, maxColumnCount)); 413maxRowHeight = Math.Max(maxRowHeight, childSize.Height); 566finalColumnCount = Math.Max(minColumnCount, Math.Min((int)(finalSize.Width / arrangeWidth), maxColumnCount)); 575maxRowHeight = Math.Max(maxRowHeight, children[i].DesiredSize.Height);

Microsoft\Windows\Controls\Ribbon\Primitives\RibbonGroupItemsPanel.cs (14)

82remainingHeightInColumn = Math.Max(0, finalSize.Height - childDesiredSize.Height); 104columnWidth = Math.Max(columnWidth, arrangeWidth); 135maxStarColumnWidth = Math.Max(maxStarColumnWidth, child.MaxWidth); 140maxStarColumnWidth = Math.Max(maxStarColumnWidth, Math.Min(child.MaxWidth, child.DesiredSize.Width)); 222desiredHeight = Math.Min(Math.Max(desiredHeight, columnHeight), availableSize.Height); 247columnWidth = Math.Max(columnWidth, GetStarChildMinWidth(child as FrameworkElement, ref maxStarColumnWidth)); 251columnWidth = Math.Max(columnWidth, childDesiredSize.Width); 252maxStarColumnWidth = Math.Max(maxStarColumnWidth, columnWidth); 257desiredHeight = Math.Min(Math.Max(desiredHeight, columnHeight), availableSize.Height); 357columnDesiredWidth = Math.Max(columnDesiredWidth, child.DesiredSize.Width); 374desiredWidth += Math.Max((columnDesiredWidth - starLayoutInfo.RequestedStarMinWidth), 0);

Microsoft\Windows\Controls\Ribbon\Primitives\RibbonGroupsPanel.cs (2)

155remainingSpace = Math.Max(0, remainingSpace - 1); 481double targetValue = Math.Min(basePerStar * starInfo.RequestedStarWeight, starInfo.RequestedStarMaxWidth);

Microsoft\Windows\Controls\Ribbon\Primitives\RibbonMenuItemsPanel.cs (3)

137maxChildWidth = Math.Max(availableSize.Width, maxChildWidth); 154double surplusHeight = Math.Max(remainingHeight, 0.0) / _registeredStarLayoutProviders.Count; 171desiredSize.Width = Math.Max(starLayoutTarget.DesiredSize.Width, desiredSize.Width);

Microsoft\Windows\Controls\Ribbon\Primitives\RibbonQuickAccessToolBarOverflowPanel.cs (2)

30panelDesiredSize.Height = Math.Max(panelDesiredSize.Height, child.DesiredSize.Height); 49rcChild.Height = Math.Max(finalSize.Height, child.DesiredSize.Height);

Microsoft\Windows\Controls\Ribbon\Primitives\RibbonQuickAccessToolBarPanel.cs (2)

216panelDesiredSize.Height = Math.Max(panelDesiredSize.Height, childDesiredSize.Height); 281rcChild.Height = Math.Max(finalSize.Height, child.DesiredSize.Height);

Microsoft\Windows\Controls\Ribbon\Primitives\RibbonScrollButtonVisibilityConverter.cs (2)

89double percent = Math.Min(100.0, Math.Max(0.0, (offset * 100.0 / (extent - viewport))));

Microsoft\Windows\Controls\Ribbon\Primitives\RibbonTabHeadersPanel.cs (11)

89_separatorOpacity = Math.Max(0.0, reducePaddingRegularTabHeader * 0.2); 122double availableExtraWidth = Math.Min(desiredExtraPaddingPerTab, availableExtraWidthPerTab); 142if (Math.Abs(desiredSize.Width - availableSize.Width) < _desiredWidthEpsilon) 395desiredSize.Height = Math.Max(desiredSize.Height, ribbonTabHeader.DesiredSize.Height); 412desiredSize.Height = Math.Max(desiredSize.Height, child.DesiredSize.Height); 443double leftPadding = Math.Max(0, ribbonTabHeader.DefaultPadding.Left - (isContextualTab ? reducePaddingContextualTabHeader : reducePaddingRegularTabHeader)); 444double rightPadding = Math.Max(0, ribbonTabHeader.DefaultPadding.Right - (isContextualTab ? reducePaddingContextualTabHeader : reducePaddingRegularTabHeader)); 450desiredSize.Height = Math.Max(desiredSize.Height, ribbonTabHeader.DesiredSize.Height); 461desiredSize.Height = Math.Max(desiredSize.Height, child.DesiredSize.Height); 526return Math.Max(_tabHeaderMinWidth, maxTabHeaderWidth); 1048return Math.Max(0.0, offset);

Microsoft\Windows\Controls\Ribbon\Primitives\RibbonTabsPanel.cs (3)

41returnSize = new Size(Math.Max(returnSize.Width, childSize.Width), Math.Max(returnSize.Height, childSize.Height)); 300return Math.Max(0.0, offset);

Microsoft\Windows\Controls\Ribbon\Primitives\RibbonTitlePanel.cs (14)

76startContextualTabX = Math.Min(CalculateContextualTabGroupStartX(firstContextualTab), availableSize.Width); 82endContextualTabX = Math.Min(CalculateContextualTabGroupEndX(lastContextualTab), availableSize.Width); 85groupHeaderItemsControl.Measure(new Size(Math.Max(endContextualTabX - startContextualTabX, 0), availableSize.Height)); 87desiredSize.Height = Math.Max(desiredSize.Height, groupHeaderItemsControl.DesiredSize.Height); 122availableToQat = Math.Max(availableToQat, 0); 129desiredSize.Height = Math.Max(desiredSize.Height, qat.DesiredSize.Height); 134endContextualTabX = Math.Max(endContextualTabX, availableToQat); 147availableToTitle = Math.Max(leftSpace, rightSpace); 153availableToTitle = Math.Max(availableToTitle, 0); 157desiredSize.Height = Math.Max(desiredSize.Height, titleHost.DesiredSize.Height); 160desiredSize.Width = Math.Min(desiredSize.Width, availableSize.Width); // Prevent clipping 185startContextualTabX = Math.Min(CalculateContextualTabGroupStartX(firstContextualTab), finalSize.Width); 188endContextualTabX = Math.Min(startContextualTabX + tabGroups.DesiredSize.Width, finalSize.Width); 201endContextualTabX = Math.Max(endContextualTabX, qatDesiredWidth);

Microsoft\Windows\Controls\Ribbon\Ribbon.cs (2)

972if (DoubleUtil.GreaterThan(Math.Abs(_mouseWheelCumulativeDelta), MouseWheelSelectionChangeThreshold)) 1593double screenWidth = Math.Abs(popupPlacementTarget.PointFromScreen(screenRect.BottomRight).X -

Microsoft\Windows\Controls\Ribbon\RibbonTwoLineText.cs (3)

394_textBlock1.Width = Math.Max(1.0, width / 2.0); 411extraLength += Math.Abs(lastCharacter.X - firstCharacter.X); 419extraLength += Math.Abs(lastCharacter.X - firstCharacter.X);

MS\Internal\Generated\DoubleUtil.cs (4)

40double eps = (Math.Abs(value1) + Math.Abs(value2) + 10.0) * DBL_EPSILON; 139return Math.Abs(value - 1.0) < 10.0 * DBL_EPSILON; 152return Math.Abs(value) < 10.0 * DBL_EPSILON;

System\Windows\Forms\Accessibility\LabelEditUiaTextProvider.cs (5)

288clientLocation.X = Math.Max(clientLocation.X, clientRectangle.left); 289clientLocation.X = Math.Min(clientLocation.X, clientRectangle.right); 290clientLocation.Y = Math.Max(clientLocation.Y, clientRectangle.top); 291clientLocation.Y = Math.Min(clientLocation.Y, clientRectangle.bottom); 344index = Math.Max(t.Length - 1, 0);

System\Windows\Forms\Application.cs (2)

384systemColorMode = Math.Abs((Registry.GetValue( 1015i = Math.Min(i, s_forms.Count); // Form can be removed from the collection, we need to check it

System\Windows\Forms\Control.cs (20)

System\Windows\Forms\Controls\Buttons\ButtonInternal\ButtonBaseAdapter.cs (2)

330size = Math.Min(size, Math.Min(bounds.Width, bounds.Height));

System\Windows\Forms\Controls\Buttons\ButtonInternal\ButtonBaseAdapter.LayoutOptions.cs (18)

132return Math.Max(checkSize, imageSize + textSize); 134return Math.Max(imageSize, textSize) + checkSize; 136return Math.Max(Math.Max(checkSize, imageSize), textSize); 578int textBottom = Math.Min(layout.TextBounds.Bottom, layout.Field.Bottom); 579layout.TextBounds.Y = Math.Max( 580Math.Min(layout.TextBounds.Y, layout.Field.Y + (layout.Field.Height - layout.TextBounds.Height) / 2), 588int textRight = Math.Min(layout.TextBounds.Right, layout.Field.Right); 589layout.TextBounds.X = Math.Max( 590Math.Min(layout.TextBounds.X, layout.Field.X + (layout.Field.Width - layout.TextBounds.Width) / 2), 598layout.ImageBounds.Width = Math.Max( 600Math.Min(maxBounds.Width - layout.TextBounds.Width, layout.ImageBounds.Width)); 607layout.ImageBounds.Height = Math.Max( 609Math.Min(maxBounds.Height - layout.TextBounds.Height, layout.ImageBounds.Height)); 645bottom = Math.Min(layout.TextBounds.Bottom, maxBounds.Bottom); 646layout.TextBounds.Y = Math.Max(layout.TextBounds.Y, maxBounds.Y); 652bottom = Math.Min(layout.TextBounds.Bottom, layout.Field.Bottom); 653layout.TextBounds.Y = Math.Max(layout.TextBounds.Y, layout.Field.Y);

System\Windows\Forms\Controls\Buttons\CheckBox.cs (1)

288size.Height = Math.Max(size.Height + 5, _flatSystemStyleMinimumHeight);

System\Windows\Forms\Controls\Buttons\RadioButton.cs (1)

260? Math.Max(size.Height + 5, _flatSystemStyleMinimumHeight)

System\Windows\Forms\Controls\ComboBox\ComboBox.ComboBoxUiaTextProvider.cs (5)

361clientLocation.X = Math.Max(clientLocation.X, clientRectangle.left); 362clientLocation.X = Math.Min(clientLocation.X, clientRectangle.right); 363clientLocation.Y = Math.Max(clientLocation.Y, clientRectangle.top); 364clientLocation.Y = Math.Min(clientLocation.Y, clientRectangle.bottom); 419index = Math.Max(t.Length - 1, 0);

System\Windows\Forms\Controls\ComboBox\ComboBox.cs (3)

2200return actualLength == PInvoke.LB_ERR ? string.Empty : buffer[..Math.Min(maxLength, actualLength)].ToString(); 3358int count = Math.Min(Math.Max(itemCount, 1), _maxDropDownItems);

System\Windows\Forms\Controls\DataGridView\DataGridView.DataConnection.cs (2)

618int lo = Math.Min(e.OldIndex, e.NewIndex); 619int hi = Math.Max(e.OldIndex, e.NewIndex);

System\Windows\Forms\Controls\DataGridView\DataGridView.Methods.cs (91)

System\Windows\Forms\Controls\DataGridView\DataGridViewButtonCell.cs (2)

391preferredSize.Width = Math.Max(preferredSize.Width, borderAndPaddingWidths + IconMarginWidth * 2 + s_iconsWidth); 401preferredSize.Height = Math.Max(preferredSize.Height, borderAndPaddingHeights + IconMarginHeight * 2 + s_iconsHeight);

System\Windows\Forms\Controls\DataGridView\DataGridViewCellStyle.cs (4)

275value.Left = Math.Max(0, value.Left); 276value.Right = Math.Max(0, value.Right); 277value.Top = Math.Max(0, value.Top); 278value.Bottom = Math.Max(0, value.Bottom);

System\Windows\Forms\Controls\DataGridView\DataGridViewCheckBoxCell.cs (2)

743preferredSize.Width = Math.Max(preferredSize.Width, 749preferredSize.Height = Math.Max(preferredSize.Height,

System\Windows\Forms\Controls\DataGridView\DataGridViewColumnHeaderCell.cs (7)

521Math.Max(1, constraintSize.Height - borderAndPaddingHeights - 2 * VerticalMargin), 549preferredSize.Width = Math.Max(preferredSize.Width, 1); 622preferredSize.Height = Math.Max(preferredSize.Height, glyphSize.Height); 623preferredSize.Height = Math.Max(preferredSize.Height, 1); 664preferredSize.Height = Math.Max(preferredSize.Height, s_sortGlyphHeight); 667preferredSize.Width = Math.Max(preferredSize.Width, 1); 668preferredSize.Height = Math.Max(preferredSize.Height, 1);

System\Windows\Forms\Controls\DataGridView\DataGridViewComboBoxCell.cs (7)

543dropHeight = Math.Min(GetDropDownButtonHeight(screen, cellStyle), adjustedSize.Height - 2); 546int dropWidth = Math.Min(SystemInformation.HorizontalScrollBarThumbWidth, adjustedSize.Width - 2 * Margin - 1); 1198preferredSize.Width = Math.Max( 1219preferredSize.Height = Math.Max(preferredSize.Height, borderAndPaddingHeights + IconMarginHeight * 2 + s_iconsHeight); 1989int dropWidth = Math.Min(SystemInformation.HorizontalScrollBarThumbWidth, valBounds.Width - 2 * Margin - 1); 1996dropHeight = Math.Min(GetDropDownButtonHeight(g, cellStyle), paintPostXPThemes ? valBounds.Height : valBounds.Height - 2); 2000dropHeight = Math.Min(GetDropDownButtonHeight(g, cellStyle), valBounds.Height - 4);

System\Windows\Forms\Controls\DataGridView\DataGridViewImageCell.cs (6)

435preferredSize = new Size(0, Math.Min(img.Height, decimal.ToInt32((decimal)img.Height * imgWidthAllowed / img.Width))); 447preferredSize = new Size(0, Math.Min(ico.Height, decimal.ToInt32((decimal)ico.Height * icoWidthAllowed / ico.Width))); 470preferredSize = new Size(Math.Min(img.Width, decimal.ToInt32((decimal)img.Width * imgHeightAllowed / img.Height)), 0); 482preferredSize = new Size(Math.Min(ico.Width, decimal.ToInt32((decimal)ico.Width * icoHeightAllowed / ico.Height)), 0); 522preferredSize.Width = Math.Max(preferredSize.Width, borderAndPaddingWidths + IconMarginWidth * 2 + s_iconsWidth); 532preferredSize.Height = Math.Max(preferredSize.Height, borderAndPaddingHeights + IconMarginHeight * 2 + s_iconsHeight);

System\Windows\Forms\Controls\DataGridView\DataGridViewLinkCell.cs (4)

576Math.Max(1, maxHeight), 590Math.Max(1, constraintSize.Width - borderAndPaddingWidths - HorizontalTextMarginLeft - HorizontalTextMarginRight), 645preferredSize.Width = Math.Max(preferredSize.Width, borderAndPaddingWidths + IconMarginWidth * 2 + s_iconsWidth); 660preferredSize.Height = Math.Max(preferredSize.Height, borderAndPaddingHeights + IconMarginHeight * 2 + s_iconsHeight);

System\Windows\Forms\Controls\DataGridView\DataGridViewRow.cs (2)

1302preferredRowThickness = Math.Max(preferredRowThickness, HeaderCell.GetPreferredHeight(rowIndex, DataGridView.RowHeadersWidth)); 1306preferredRowThickness = Math.Max(preferredRowThickness, HeaderCell.GetPreferredSize(rowIndex).Height);

System\Windows\Forms\Controls\DataGridView\DataGridViewTextBoxCell.cs (11)

System\Windows\Forms\Controls\DataGridView\DataGridViewUtilities.cs (3)

200preferredWidth = Math.Max(preferredWidth, 1); 255return new Size(0, Math.Max(minHeightIcon, minHeightContent) + borderAndPaddingHeights); 293preferredSize.Height = Math.Max(preferredSize.Height,

System\Windows\Forms\Controls\GroupBox\GroupBox.cs (3)

166Math.Max(size.Width - padding.Horizontal, 0), 167Math.Max(size.Height - _fontHeight - padding.Vertical, 0)); 541int textRight = Math.Min(textLeft + textSize.Width, Width - 6);

System\Windows\Forms\Controls\GroupBox\GroupBoxRenderer.cs (1)

218clipMiddle.Width = Math.Max(0, textBounds.Width - 3); // -3 to account for the margin built in the MeasureText result

System\Windows\Forms\Controls\ImageList\ImageList.cs (1)

564int length = Math.Abs(targetData.Stride);

System\Windows\Forms\Controls\Labels\LinkLabel.cs (3)

637int length = Math.Min(link.Length, textLen - link.Start); 1680int maxStart = Math.Max(left.Start, right.Start); 1681int minEnd = Math.Min(left.Start + left.Length, right.Start + right.Length);

System\Windows\Forms\Controls\Labels\LinkUtilities.cs (1)

44int nMax = Math.Min(rgb.Length, rgbsCount);

System\Windows\Forms\Controls\ListBoxes\CheckedListBox.cs (2)

532int centeringFactor = Math.Max((height - _idealCheckSize) / 2, 0); 646if (Math.Abs(tabOffset) < tabDistance)

System\Windows\Forms\Controls\ListBoxes\ListBox.cs (7)

1308return Math.Max(oldMax, textSize.Width); 1416ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual(index, Math.Max(1, itemCount)); 1578return actualLength == PInvoke.LB_ERR ? string.Empty : buffer[..Math.Min(maxLength, actualLength)].ToString(); 2282width = (int)(Math.Ceiling(graphics.MeasureString(GetItemText(item), Font).Width)); 2357bounds.Width = MultiColumn ? Math.Max(ColumnWidth, bounds.Width) : Math.Max(MaxItemWidth, bounds.Width); 2482Height = Math.Max(Height, ItemHeight);

System\Windows\Forms\Controls\ListBoxes\ListBox.IntegerCollection.cs (2)

210_innerArray = new int[Math.Max(elements, 4)]; 214int newLength = Math.Max(_innerArray.Length * 2, _innerArray.Length + elements);

System\Windows\Forms\Controls\ListView\ColumnHeader.cs (2)

131int lowDI = Math.Min(DisplayIndexInternal, value); 132int hiDI = Math.Max(DisplayIndexInternal, value);

System\Windows\Forms\Controls\ListView\ListView.cs (13)

System\Windows\Forms\Controls\ListView\ListViewGroup.ListViewGroupAccessibleObject.cs (4)

65groupRect.top = Math.Max(listViewBounds.Top, groupRect.top); 66groupRect.bottom = Math.Min(listViewBounds.Bottom, groupRect.bottom); 67groupRect.left = Math.Max(listViewBounds.Left, groupRect.left); 68groupRect.right = Math.Min(listViewBounds.Right, groupRect.right);

System\Windows\Forms\Controls\ListView\ListViewItem.IKeyboardToolTip.cs (3)

114new Size(Math.Min(TextRenderer.MeasureText(item.Text, item.Font).Width, itemBounds.Width), 128textWidth = Math.Max(TextRenderer.MeasureText(subItem.Text, subItem.Font).Width, textWidth); 131return new Rectangle(point, new Size(Math.Min(textWidth, itemBounds.Width), itemBounds.Height));

System\Windows\Forms\Controls\ListView\ListViewItem.ListViewItemTileAccessibleObject.cs (1)

109int subItemCount = Math.Min(_owningListView.Columns.Count, _owningItem.SubItems.Count);

System\Windows\Forms\Controls\Menus\MenuTimer.cs (1)

23_slowShow = Math.Max(_quickShow, SystemInformation.MenuShowDelay);

System\Windows\Forms\Controls\MonthCalendar\MonthCalendar.MonthCalendarAccessibleObject.cs (1)

540? (int)Math.Ceiling((double)CalendarsAccessibleObjects.Count / ColumnCount)

System\Windows\Forms\Controls\PictureBox\PictureBox.cs (1)

367float ratio = Math.Min(ClientRectangle.Width / (float)imageSize.Width, ClientRectangle.Height / (float)imageSize.Height);

System\Windows\Forms\Controls\PropertyGrid\PropertyGrid.cs (13)

1923if (Math.Abs(gridBottom - y) <= 1 && y > gridTop) 1954y = Math.Min((rectTarget.Y + rectTarget.Height - 15), y); 1957return Math.Max(DividerLimitHigh(target), y); 2576int sx = (int)Math.Round(Left * dx); 2577int sy = (int)Math.Round(Top * dy); 2578int sw = (int)Math.Round((Left + Width) * dx - sx); 2579int sh = (int)Math.Round((Top + Height) * dy - sy); 2692height = Math.Min(helpRequestedHeight, maxSpace); 2702height = Math.Min(helpRequestedHeight, maxSpace / 2 - 1); 2705height = Math.Max(height, s_cyDivider * 2); 2732height = Math.Min(commandsRequestedHeight, maxSpace); 2740height = Math.Max(height, s_cyDivider * 2); 2824size.Height = Math.Max(0, yNew);

System\Windows\Forms\Controls\PropertyGrid\PropertyGridInternal\GridEntry.cs (1)

1570int maxSpace = Math.Min(rect.Width - stringX - 1, labelWidth + PropertyGridView.GdiPlusSpace);

System\Windows\Forms\Controls\PropertyGrid\PropertyGridInternal\GridErrorDialog.cs (2)

302int detailsWidth = (int)Math.Ceiling(sizef.Width); 304_detailsButton.Width = (int)Math.Ceiling(detailsWidth * (_ownerGrid.UseCompatibleTextRendering ? 1.15f : 1.4f));

System\Windows\Forms\Controls\PropertyGrid\PropertyGridInternal\HelpPane.cs (6)

94return Math.Max(height + 2 * padding, isScalingRequirementMet ? LogicalToDeviceUnits(LogicalDefaultHeight) : LogicalDefaultHeight); 151size.Width = Math.Max(0, size.Width - 2 * _borderSize); 152size.Height = Math.Max(0, size.Height - 2 * _borderSize); 158Math.Min(_lineHeight, size.Height), 165Math.Max(0, size.Height - _lineHeight - (ScaleHelper.IsScalingRequirementMet ? LogicalToDeviceUnits(1) : 1)), 209int lines = Math.Max(MinimumLines, newHeight / _lineHeight);

System\Windows\Forms\Controls\PropertyGrid\PropertyGridInternal\PropertyGridView.cs (30)

400set => _requiredLabelPaintMargin = (short)Math.Max(Math.Max(value, _requiredLabelPaintMargin), GdiPlusSpace); 1421size.Width = Math.Max(rect.Width + 1, size.Width); 1423location.X = Math.Min( 1425Math.Max(rectScreen.X, location.X + rect.X + rect.Width - size.Width)); 2101int pos = Math.Max(Math.Min(xPosition, widthPS - 10), OutlineIconSize * 2); 2606if (Math.Abs(screenPoint.X - _rowSelectPos.X) < SystemInformation.DoubleClickSize.Width && 2607Math.Abs(screenPoint.Y - _rowSelectPos.Y) < SystemInformation.DoubleClickSize.Height) 3190int newOffset = Math.Max(0, initialOffset - large); 3191newOffset = Math.Min(newOffset, TotalProperties - _visibleRows + 1); 3194if (Math.Abs(initialOffset - originalOffset) >= Math.Abs(fullNotches * _scrollBar.LargeChange)) 3223int newOffset = Math.Max(0, initialOffset - scrollBands); 3224newOffset = Math.Min(newOffset, TotalProperties - _visibleRows + 1); 3290startRow = Math.Max(0, startPosition.Y); 3298int visibleCount = Math.Min(TotalProperties - GetScrollOffset(), 1 + _visibleRows); 3314visibleCount = Math.Min(visibleCount, endRow + 1); 3723maxWidth = Math.Max(textSize.Width, maxWidth); 3739DropDownListBox.Height = Math.Max(tm.tmHeight + 2, Math.Min(_maxListBoxHeight, DropDownListBox.PreferredHeight)); 3740DropDownListBox.Width = Math.Max(maxWidth, GetRectangle(row, RowValue).Width); 4223int maxRows = (int)Math.Ceiling(((double)GetOurSize().Height) / (1 + RowHeight)); 4432_visibleRows = (int)Math.Ceiling(((double)size.Height) / (1 + RowHeight)); 4438_labelRatio = Math.Max(Math.Min(_labelRatio, 9), 1.1); 4558int newPosition = Math.Max(0, Math.Min(TotalProperties - _visibleRows + 1, offset)); 4830ScrollBar.Maximum = Math.Max(0, TotalProperties - 1); 5045private bool SplitterInside(int x) => Math.Abs(x - LabelWidth) < 4;

System\Windows\Forms\Controls\PropertyGrid\PropertyGridInternal\PropertyGridView.DropDownHolder.cs (4)

375else if (!_resizeUp && Math.Abs(Height - y) < s_resizeBorderSize) 379else if (_resizeUp && Math.Abs(y) < s_resizeBorderSize) 435newBounds.Height = Math.Max(s_minDropDownSize.Height, _dragBaseRect.Height + (dragPoint.Y - _dragStart.Y)); 591listBox.Height = Math.Max(listBox.Height, listBox.ItemHeight);

System\Windows\Forms\Controls\RichTextBox\RichTextBox.cs (4)

2036txrg.chrg.cpMax = Math.Min(txrg.chrg.cpMax, end); 2227index = Math.Max(t.Length - 1, 0); 2677numerator = (int)Math.Ceiling(multiplier); 2680numerator = (int)Math.Floor(multiplier);

System\Windows\Forms\Controls\Splitter\Splitter.cs (2)

798return Math.Max(Math.Min(size, _maxSize), _minSize);

System\Windows\Forms\Controls\TextBox\TextBoxBase.cs (6)

853textSize.Height = Math.Max(textSize.Height, FontHeight); 886start = Math.Max(0, start); 888end = Math.Max(0, end); 1194Height = Math.Max(saveHeight, PreferredHeight + 2); // 2 = fudge factor 1565index = Math.Max(t.Length - 1, 0); 1701long longLength = Math.Min(0, (long)length + start - textLen);

System\Windows\Forms\Controls\TextBox\TextBoxBase.TextBoxBaseUiaTextProvider.cs (5)

126clientLocation.X = Math.Max(clientLocation.X, clientRectangle.left); 127clientLocation.X = Math.Min(clientLocation.X, clientRectangle.right); 128clientLocation.Y = Math.Max(clientLocation.Y, clientRectangle.top); 129clientLocation.Y = Math.Min(clientLocation.Y, clientRectangle.bottom); 259return fontHeight != 0 ? (int)Math.Ceiling(((double)rect.Height) / fontHeight) : 0;

System\Windows\Forms\Controls\ToolStrips\StatusStrip.cs (5)

209int gripHeight = Math.Min(DefaultSize.Height, statusStripSize.Height); 503TableLayoutSettings.RowStyles[0].Height = Math.Max(0, DisplayRectangle.Height); 551TableLayoutSettings.ColumnStyles[0].Width = Math.Max(0, DisplayRectangle.Width); 599int deltaBottomEdge = Math.Abs(rootHwndClientArea.bottom - gripLocation.Y); 600int deltaRightEdge = Math.Abs(rootHwndClientArea.right - gripLocation.X);

System\Windows\Forms\Controls\ToolStrips\ToolStrip.cs (11)

2170double hypotenuse = Math.Sqrt(adjacentSide * adjacentSide + oppositeSide * oppositeSide); 2180double tan = Math.Abs(Math.Atan(oppositeSide / adjacentSide)); 2183minTan = Math.Min(minTan, tan); 2184minHypotenuse = Math.Min(minHypotenuse, hypotenuse); 2273maxSize.Height = Math.Max(0, defaultSize.Height); 2290maxSize.Height = Math.Max(maxSize.Height, itemMargin.Vertical + prefItemSize.Height); 2349maxSize.Width = Math.Max(maxSize.Width, itemMargin.Horizontal + preferredSize.Width); 2880startIndex = Math.Max(0, startIndex); 4176gripRectangle.X = Math.Max(0, displayRect.X - Grip.GripThickness); 4177gripRectangle.Y = Math.Max(0, displayRect.Top - Grip.Margin.Top);

System\Windows\Forms\Controls\ToolStrips\ToolStripButton.cs (1)

162prefSize.Width = Math.Max(prefSize.Width, _standardButtonWidth);

System\Windows\Forms\Controls\ToolStrips\ToolStripComboBox.cs (1)

325preferredSize.Width = Math.Max(preferredSize.Width, 75);

System\Windows\Forms\Controls\ToolStrips\ToolStripDropDown.cs (2)

571value = Math.Clamp(value, 0.0d, 1.0d); 1885_countDropDownItemsAssignedTo = Math.Max(--_countDropDownItemsAssignedTo, 0);

System\Windows\Forms\Controls\ToolStrips\ToolStripDropDownMenu.cs (16)

299menuItemTextSize.Height = Math.Max(menuItemTextSize.Height, shortcutTextSize.Height); 303maxTextSize.Width = Math.Max(maxTextSize.Width, menuItemTextSize.Width); 304maxTextSize.Height = Math.Max(maxTextSize.Height, menuItemTextSize.Height); 313maxImageSize.Width = Math.Max(maxImageSize.Width, imageSize.Width); 314maxImageSize.Height = Math.Max(maxImageSize.Height, imageSize.Height); 319maxCheckSize.Width = Math.Max(checkedImageSize.Width, maxCheckSize.Width); 320maxCheckSize.Height = Math.Max(checkedImageSize.Height, maxCheckSize.Height); 325maxNonMenuItemSize.Height = Math.Max(item.Bounds.Height, maxNonMenuItemSize.Height); 326maxNonMenuItemSize.Width = Math.Max(item.Bounds.Width, maxNonMenuItemSize.Width); 330_maxItemSize.Height = Math.Max(maxTextSize.Height + _textPadding.Vertical, Math.Max(maxCheckSize.Height + _checkPadding.Vertical, maxArrowSize.Height + _arrowPadding.Vertical)); 335_maxItemSize.Height = Math.Max(maxImageSize.Height + _imagePadding.Vertical, _maxItemSize.Height); 346maxTextSize.Width = Math.Max(maxTextSize.Width, maxNonMenuItemSize.Width); 351int extraImageWidth = Math.Max(0, maxImageSize.Width - _defaultImageSize.Width); 839minY = Math.Min(minY, item.Bounds.Top); 840maxY = Math.Max(maxY, item.Bounds.Bottom);

System\Windows\Forms\Controls\ToolStrips\ToolStripManager.cs (4)

397if (nextControl is not null && Math.Abs(nextControl.TabIndex - startTabIndex) <= 1) 1226int insertIndex = Math.Min(destinationItems.Count, source.MergeIndex); 1332historyItem.PreviousIndexCollection!.Insert(Math.Min(historyItem.PreviousIndex, historyItem.PreviousIndexCollection.Count), historyItem.TargetItem!); 1335historyItem.IndexCollection!.Insert(Math.Min(historyItem.Index, historyItem.IndexCollection.Count), historyItem.TargetItem!);

System\Windows\Forms\Controls\ToolStrips\ToolStripMenuItem.cs (1)

1073rect.X = Math.Max(rect.X, 0);

System\Windows\Forms\Controls\ToolStrips\ToolStripOverflowButton.cs (2)

78preferredSize.Width = Math.Min(constrainingSize.Width, s_maxSize); 82preferredSize.Height = Math.Min(constrainingSize.Height, s_maxSize);

System\Windows\Forms\Controls\ToolStrips\ToolStripPanelRow.cs (4)

443cachedBounds.X -= Math.Max(0, margins[i] - c.Margin.Left); 475cellOffsets[j] += Math.Max(0, currentCell.CachedBounds.Width - cachedBounds.Width); 540cachedBounds.X = Math.Max(0, cachedBounds.X - margins[i] - c.Margin.Top); 572cellOffsets[j] += Math.Max(0, currentCell.CachedBounds.Height - cachedBounds.Height);

System\Windows\Forms\Controls\ToolStrips\ToolStripPanelRow.HorizontalRowManager.cs (4)

136return requiredSpace - Math.Max(0, spaceToFree); 481nextCellMargin.Left = Math.Max(0, nextCellMargin.Left - freedSpace); 496lastCellMargin.Left = Math.Max(0, locationToDrag.X - nextCell.Bounds.Right); 543cellMargin.Left = Math.Max(0, locationToDrag.X - Row.Margin.Left);

System\Windows\Forms\Controls\ToolStrips\ToolStripPanelRow.VerticalRowManager.cs (3)

138return requiredSpace - Math.Max(0, spaceToFree); 506lastCellMargin.Top = Math.Max(0, locationToDrag.Y - nextCell.Bounds.Bottom); 547cellMargin.Top = Math.Max(0, locationToDrag.Y - Row.Margin.Top);

System\Windows\Forms\Controls\ToolStrips\ToolstripProfessionalRenderer.cs (1)

1465bounds.Height = Math.Max(0, bounds.Height - 6);

System\Windows\Forms\Controls\ToolStrips\ToolStripSplitButton.cs (3)

301Rectangle dropDownButtonBounds = new(Point.Empty, new Size(Math.Min(Width, DropDownButtonWidth), Height)); 304int splitButtonButtonWidth = Math.Max(0, Width - dropDownButtonBounds.Width); 305int splitButtonButtonHeight = Math.Max(0, Height);

System\Windows\Forms\Controls\ToolStrips\ToolStripSplitStackDragDropHandler.cs (4)

85int insertIndex = Math.Max(0, toolStripItemIndex); 102insertIndex = Math.Max(0, (_owner.RightToLeft == RightToLeft.Yes) ? insertIndex + 1 : insertIndex); 110insertIndex = Math.Max(0, (_owner.RightToLeft == RightToLeft.No) ? insertIndex + 1 : insertIndex); 121_owner.Items.MoveItem(Math.Max(0, insertIndex), droppedItem);

System\Windows\Forms\Controls\ToolStrips\ToolStripSplitStackLayout.cs (2)

334itemSize.Height = Math.Max(_displayRectangle.Height - itemMargin.Vertical, 0); 467itemSize.Width = Math.Max(toolStripPreferredSize.Width - itemMargin.Horizontal - 1, 0);

System\Windows\Forms\Controls\ToolStrips\ToolStripSystemRenderer.cs (1)

291bounds.Y = Math.Max(0, (e.GripBounds.Height - bounds.Height - 2/*number of pixels for border*/) / 2);

System\Windows\Forms\Controls\TrackBar\TrackBar.cs (2)

958Value = Math.Min(absScrollBands + Value, Maximum); 964Value = Math.Max(Value - absScrollBands, Minimum);

System\Windows\Forms\Controls\TrackBar\TrackBarRenderer.cs (2)

130t_visualStyleRenderer.DrawEdge(g, new Rectangle((int)Math.Round(x), bounds.Y, LineWidth, bounds.Height), Edges.Left, edgeStyle, EdgeEffects.None); 160t_visualStyleRenderer.DrawEdge(g, new Rectangle(bounds.X, (int)Math.Round(y), bounds.Width, LineWidth), Edges.Top, edgeStyle, EdgeEffects.None);

System\Windows\Forms\Controls\TreeView\TreeNode.cs (1)

2208iImage = Math.Max(

System\Windows\Forms\Controls\TreeView\TreeView.cs (3)

545return Math.Max(0, _imageList.Images.Count - 1); 787return Math.Max(16, FontHeight + 3); 1016return Math.Max(0, _imageList.Images.Count - 1);

System\Windows\Forms\Controls\UpDown\NumericUpDown.cs (7)

770int numDigits = (int)Math.Floor(Math.Log(Math.Max(-(double)Minimum, (double)Maximum), baseSize)); 774maxDigits = (int)Math.Floor(Math.Log(long.MaxValue, baseSize)); 778maxDigits = (int)Math.Floor(Math.Log((double)decimal.MaxValue, baseSize));

System\Windows\Forms\DataBinding\Command.cs (1)

76icmdLim = Math.Min(IdLim - IdMin, 2 * icmd);

System\Windows\Forms\DataBinding\CurrencyManager.cs (3)

372listposition = Math.Min(newPosition, Count - 1); 690ChangeRecordState(Math.Min(listposition, _list.Count - 1), true, false, true, false); 742ChangeRecordState(Math.Min(listposition, Count - 1), true, false, true, false);

System\Windows\Forms\Dialogs\CommonDialogs\ColorDialog.cs (1)

87MemoryMarshal.Cast<int, COLORREF>(value)[..Math.Min(customColors.Length, value.Length)].CopyTo(customColors);

System\Windows\Forms\Dialogs\TaskDialog\TaskDialog.cs (1)

1100_buttonClickNavigationCounter.navigationIndex = Math.Min(

System\Windows\Forms\Dialogs\ThreadExceptionDialog.cs (3)

234int buttonTop = Math.Max(textSize.Height, _scaledMaxTextHeight) + _scaledPaddingHeight; 265_scaledMessageTopPadding + (_scaledMaxTextHeight - Math.Min(textSize.Height, _scaledMaxTextHeight)) / 2, 349_scaledHeightPadding = (int)Math.Round(HEIGHTPADDING * ((float)e.DeviceDpiNew / e.DeviceDpiOld));

System\Windows\Forms\Form.cs (17)

449return new Size((int)Math.Round(real.Width), (int)Math.Round(real.Height)); 1243Size = new Size(Math.Min(size.Width, value.Width), Math.Min(size.Height, value.Height)); 1360Size = new Size(Math.Max(size.Width, value.Width), Math.Max(size.Height, value.Height)); 1576value = Math.Clamp(value, 0.0d, 1.0d); 2981Size newVar = new((int)Math.Round(newVarF.Width), (int)Math.Round(newVarF.Height)); 3649cp.X = Math.Max(clientRect.X, clientRect.X + (clientRect.Width - cp.Width) / 2); 3650cp.Y = Math.Max(clientRect.Y, clientRect.Y + (clientRect.Height - cp.Height) / 2); 3674cp.X = Math.Max(screenRect.X, screenRect.X + (screenRect.Width - cp.Width) / 2); 3675cp.Y = Math.Max(screenRect.Y, screenRect.Y + (screenRect.Height - cp.Height) / 2); 3911p.X = Math.Max(screenRect.X, screenRect.X + (screenRect.Width - Width) / 2); 3912p.Y = Math.Max(screenRect.Y, screenRect.Y + (screenRect.Height - Height) / 2); 6806mmi->ptMaxTrackSize.X = Math.Max(maxTrack.Width, minTrackWindowSize.Width); 6807mmi->ptMaxTrackSize.Y = Math.Max(maxTrack.Height, minTrackWindowSize.Height);

System\Windows\Forms\Internal\WinFormsUtils.cs (2)

82bounds.Size = new Size(Math.Min(constrainingBounds.Width - 2, bounds.Width), 83Math.Min(constrainingBounds.Height - 2, bounds.Height));

System\Windows\Forms\Layout\CommonProperties.cs (4)

207bounds.Width = Math.Min(bounds.Width, value.Width); 208bounds.Height = Math.Min(bounds.Height, value.Height); 231bounds.Width = Math.Max(bounds.Width, value.Width); 232bounds.Height = Math.Max(bounds.Height, value.Height);

System\Windows\Forms\Layout\Containers\ContainerControl.cs (1)

736retval.Width = (int)Math.Round(size.Width / ((float)FontMeasureString.Length));

System\Windows\Forms\Layout\Containers\SplitContainer.cs (27)

955_splitterDistance = (_splitterDistance < Panel1MinSize) ? _splitterDistance + SplitterIncrement : Math.Max(_splitterDistance, _borderSize); 1092x = Math.Max(Math.Min(x, Width - Panel2MinSize), Panel1MinSize); 1093y = Math.Max(y, 0); 1097y = Math.Max(Math.Min(y, Height - Panel2MinSize), Panel1MinSize); 1098x = Math.Max(x, 0); 1507size = Math.Max(Panel1.Width + delta, _borderSize); 1512size = Math.Max(Panel1.Width - delta, _borderSize); 1517size = Math.Max(Panel1.Height + delta, _borderSize); 1523return Math.Max(Math.Min(size, Width - Panel2MinSize), Panel1MinSize); 1527return Math.Max(Math.Min(size, Height - Panel2MinSize), Panel1MinSize); 1620Panel2.Size = new Size(Math.Max(Width - _panelSize - SplitterWidthInternal, Panel2MinSize), Height); 1626_splitterDistance = Math.Max(Width - _panelSize - SplitterWidthInternal, Panel1MinSize); 1635_splitterDistance = Math.Max((int)(Math.Floor(Width / _ratioWidth)), Panel1MinSize); 1640Panel2.Size = new Size(Math.Max(Width - _splitterDistance - SplitterWidthInternal, Panel2MinSize), Height); 1679Panel2.Size = new Size(Width, Math.Max(Height - panel2Start, Panel2MinSize)); 1686_splitterDistance = Math.Max(Height - Panel2.Height - SplitterWidthInternal, Panel1MinSize); 1698_splitterDistance = Math.Max((int)(Math.Floor(Height / _ratioHeight)), Panel1MinSize); 1704Panel2.Size = new Size(Width, Math.Max(Height - panel2Start, Panel2MinSize)); 1768SplitterWidth = (int)Math.Round(SplitterWidth * scale); 1769_splitterDistance = (int)Math.Round(_splitterDistance * scale); 1775_panelSize = (int)Math.Round(_panelSize * scale);

System\Windows\Forms\Layout\DefaultLayout.cs (28)

305left = Math.Max(Math.Abs(left), Math.Abs(cachedBounds.Left)); 308right = left + Math.Max(element.Bounds.Width, cachedBounds.Width) + Math.Abs(right); 313right = right > 0 ? right : element.Bounds.Right + Math.Abs(right); 323top = Math.Max(Math.Abs(top), Math.Abs(cachedBounds.Top)); 326bottom = top + Math.Max(element.Bounds.Height, cachedBounds.Height) + Math.Abs(bottom); 331bottom = bottom > 0 ? bottom : element.Bounds.Bottom + Math.Abs(bottom); 488Math.Max(0, newElementBounds.Width - remainingBounds.Width), 489Math.Max(0, newElementBounds.Height - remainingBounds.Height)); 545newSize.Width = Math.Max(newSize.Width, remainingSize.Width); 562newSize.Height = Math.Max(newSize.Height, remainingSize.Height); 993anchorInfo.Left = (int)Math.Round(anchorInfo.Left * widthFactor); 994anchorInfo.Top = (int)Math.Round(anchorInfo.Top * heightFactor); 995anchorInfo.Right = (int)Math.Round(anchorInfo.Right * widthFactor); 996anchorInfo.Bottom = (int)Math.Round(anchorInfo.Bottom * heightFactor); 1129prefSize.Width = Math.Max(prefSize.Width, elementSpace.Right); 1136prefSize.Height = Math.Max(prefSize.Height, elementSpace.Bottom); 1147prefSize.Width = Math.Max(prefSize.Width, anchorInfo is null ? bounds.Right : bounds.Right + anchorInfo.Right); 1153? Math.Max(prefSize.Width, elementSpace.Right + anchorDest.Width) 1154: Math.Max(prefSize.Width, anchorDest.Right); 1167prefSize.Height = Math.Max(prefSize.Height, anchorInfo is null ? bounds.Bottom : bounds.Bottom + anchorInfo.Bottom); 1172? Math.Max(prefSize.Height, elementSpace.Bottom + anchorDest.Height) 1173: Math.Max(prefSize.Height, anchorDest.Bottom);

System\Windows\Forms\Layout\FlowLayout.cs (2)

93layoutSize.Width = Math.Max(layoutSize.Width, rowSize.Width); 253rowSize.Height = Math.Max(rowSize.Height, requiredSize.Height);

System\Windows\Forms\Layout\LayoutUtils.cs (12)

51largestSize.Width = Math.Max(largestSize.Width, textSize.Width); 52largestSize.Height = Math.Max(largestSize.Height, textSize.Height); 145padding.Left = Math.Max(0, padding.Left); 146padding.Top = Math.Max(0, padding.Top); 147padding.Right = Math.Max(0, padding.Right); 148padding.Bottom = Math.Max(0, padding.Bottom); 208Math.Max(a.Width, b.Width), 209Math.Max(a.Height, b.Height)); 215Math.Min(a.Width, b.Width), 216Math.Min(a.Height, b.Height)); 399currentSize.Width = Math.Max(currentSize.Width, contentSize.Width); 405currentSize.Height = Math.Max(currentSize.Height, contentSize.Height);

System\Windows\Forms\Layout\TableLayout.ContainerInfo.cs (2)

261_minColumns = Math.Max(_minColumns, layoutInfo.ColumnPosition + layoutInfo.ColumnSpan); 262_minRows = Math.Max(_minRows, layoutInfo.RowPosition + layoutInfo.RowSpan);

System\Windows\Forms\Layout\TableLayout.cs (43)

108containerSize.Width = Math.Max(containerSize.Width, 1); 109containerSize.Height = Math.Max(containerSize.Height, 1); 165containerSize.Width = Math.Max(containerSize.Width, 1); 166containerSize.Height = Math.Max(containerSize.Height, 1); 168containerInfo.ColumnStyles[0].SetSize(Math.Max(oldWidth, Math.Min(proposedConstraints.Width, containerSize.Width))); 178proposedConstraints.Width = Math.Max(proposedConstraints.Width, 1); 179proposedConstraints.Height = Math.Max(proposedConstraints.Height, 1); 267numRows = Math.Max(1, numRows); 268numCols = Math.Max(1, numCols); 289int estimatedCols = Math.Max((int)Math.Ceiling((float)minSpace / numRows), minColumn); 292estimatedCols = Math.Max(estimatedCols, 1); 306xAssignRowsAndColumns(containerInfo, childrenInfo, maxColumns: Math.Max(minColumn, 1), maxRows: int.MaxValue, growStyle); 371rowStop = Math.Min(currentRow + flowElement.RowSpan, maxRows); 391fixedElement!.RowStart = Math.Min(fixedElement.RowPosition, maxRows - 1); 392fixedElement.ColumnStart = Math.Min(fixedElement.ColumnPosition, maxColumns - 1); 401fixedElement.ColumnStart = Math.Max(fixedElement.ColumnStart, currentCol); 408fixedElement.RowStart = Math.Max(fixedElement.RowStart, currentRow); 436colStop = Math.Min(fixedElement.ColumnStart + fixedElement.ColumnSpan, maxColumns); 437rowStop = Math.Min(fixedElement.RowStart + fixedElement.RowSpan, maxRows); 446numRows = (numRows == int.MaxValue) ? rowStop : Math.Max(numRows, rowStop); 447numColumns = (numColumns == int.MaxValue) ? colStop : Math.Max(numColumns, colStop); 463numRows = Math.Max(containerInfo.MaxRows, numRows); 468numColumns = Math.Max(containerInfo.MaxColumns, numColumns); 591colStop = Math.Min(layoutInfo.ColumnSpan, maxColumns); 646int expandLastElementWidth = Math.Max(0, proposedConstraints.Width - preferredSize.Width); 661strip.MinSize = (int)Math.Round((double)styles[i].Size); 741int colStop = Math.Min(layoutInfo.ColumnStart + layoutInfo.ColumnSpan, containerInfo.Columns.Length); 780int stealAmount = Math.Min(currentOverflow, totalPercentAllocatedSpace); 858int rowStop = Math.Min(layoutInfo.RowStart + layoutInfo.RowSpan, containerInfo.Rows.Length); 874for (int i = start; i < Math.Min(start + span, strips.Length); i++) 901desiredLength = Math.Max(0, desiredLength); 957int offset = Math.Min(sizeProxy.Size, missingLength); 1077totalPercentAllocatedSpace = Math.Max(0, maxSize - totalAbsoluteAndAutoSizeAllocatedSpace); 1133int totalWidth = (int)Math.Round(((strip.MinSize * totalPercent) / style.Size)); 1134maxPercentWidth = Math.Max(maxPercentWidth, totalWidth); 1157int delta = Math.Min(strip.MaxSize - strip.MinSize, remainingSpace); 1263cellBounds.Width = Math.Max(cellBounds.Width, 1); 1264cellBounds.Height = Math.Max(cellBounds.Height, 1); 1272elementBounds.Width = Math.Min(cellBounds.Width, elementBounds.Width); 1273elementBounds.Height = Math.Min(cellBounds.Height, elementBounds.Height); 1413minColumn = Math.Max(minColumn, layoutInfo.ColumnPosition + layoutInfo.ColumnSpan);

System\Windows\Forms\MDI\MDIClient.cs (4)

195int sx = (int)Math.Round(bounds.X * dx); 196int sy = (int)Math.Round(bounds.Y * dy); 197int sw = (int)Math.Round((bounds.X + bounds.Width) * dx - sx); 198int sh = (int)Math.Round((bounds.Y + bounds.Height) * dy - sy);

System\Windows\Forms\Panels\TableLayoutPanel\TableLayoutPanel.cs (4)

529cs.Width = (float)Math.Round(lastColumnHeight * factor.Width); 533cs.Width = (float)Math.Round(cs.Width * factor.Width); 550rs.Height = (float)Math.Round(lastRowHeight * factor.Height); 554rs.Height = (float)Math.Round(rs.Height * factor.Height);

System\Windows\Forms\Printing\PageSetupDialog.cs (4)

322dialogSettings.rtMargin.left = Math.Max(dialogSettings.rtMargin.left, dialogSettings.rtMinMargin.left); 323dialogSettings.rtMargin.top = Math.Max(dialogSettings.rtMargin.top, dialogSettings.rtMinMargin.top); 324dialogSettings.rtMargin.right = Math.Max(dialogSettings.rtMargin.right, dialogSettings.rtMinMargin.right); 325dialogSettings.rtMargin.bottom = Math.Max(dialogSettings.rtMargin.bottom, dialogSettings.rtMinMargin.bottom);

System\Windows\Forms\Printing\PrintPreviewControl.cs (11)

211value = Math.Min(value, _pageInfo.Length - (_rows * _columns)); 214value = Math.Max(value, 0); 430rect.Width = Math.Max(0, rect.Width - 1); 431rect.Height = Math.Max(0, rect.Height - 1); 488_zoom = Math.Min(zoomX, zoomY); 626Math.Max(0, (rect.Width - _virtualSize.Width) / 2), 627Math.Max(0, (rect.Height - _virtualSize.Height) / 2)); 658_zoom = Math.Min(zoomX, zoomY); 670maxImageHeight = Math.Max(maxImageHeight, imagePixels.Height); 764_hScrollBar.Value = Math.Clamp(value.X, _hScrollBar.Minimum, _hScrollBar.Maximum); 765_vScrollBar.Value = Math.Clamp(value.Y, _vScrollBar.Minimum, _vScrollBar.Maximum);

System\Windows\Forms\Rendering\ControlPaint.cs (3)

1896int minDim = Math.Min(width, height); 1916int size = Math.Min(width, height); 2416if (Math.Abs(pixelColorWrapper.Luminosity - backgroundColorWrapper.Luminosity) > MaximumLuminosityDifference)

System\Windows\Forms\Rendering\ControlPaint.HLSColor.cs (4)

38int max = Math.Max(Math.Max(r, g), b); 39int min = Math.Min(Math.Min(r, g), b);

System\Windows\Forms\Rendering\FontCache.Data.cs (1)

83int pixelsY = (int)Math.Ceiling(ScaleHelper.InitialSystemDpi * font.SizeInPoints / 72);

System\Windows\Forms\Rendering\TextExtensions.cs (4)

119leftMargin = (int)Math.Ceiling(overhangPadding); 120rightMargin = (int)Math.Ceiling(overhangPadding * (1 + ItalicPaddingFactor)); 126leftMargin = (int)Math.Ceiling(2 * overhangPadding); 127rightMargin = (int)Math.Ceiling(overhangPadding * (2 + ItalicPaddingFactor));

System\Windows\Forms\Scrolling\ScrollableControl.cs (8)

223displayRectangle.Width = Math.Max(displayRectangle.Width, AutoScrollMinSize.Width); 224displayRectangle.Height = Math.Max(displayRectangle.Height, AutoScrollMinSize.Height); 614pos = Math.Max(pos - e.Delta, 0); 615pos = Math.Min(pos, maxPos); 630pos = Math.Max(pos - e.Delta, 0); 631pos = Math.Min(pos, maxPos); 749int minX = Math.Min(client.Width - displayRectangle.Width, 0); 750int minY = Math.Min(client.Height - displayRectangle.Height, 0);

System\Windows\Forms\Scrolling\ScrollBar.cs (7)

216return Math.Min(_largeChange, _maximum - _minimum + 1); 304return Math.Min(_smallChange, LargeChange); 541while (Math.Abs(_wheelDelta) >= PInvoke.WHEEL_DELTA) 683newValue = Math.Max(_value - SmallChange, _minimum); 687newValue = Math.Min(_value + SmallChange, _maximum - LargeChange + 1); 691newValue = Math.Max(_value - LargeChange, _minimum); 695newValue = Math.Min(_value + LargeChange, _maximum - LargeChange + 1);

System\Windows\Forms\Scrolling\ScrollProperties.cs (2)

81return Math.Min(_largeChange, _maximum - _minimum + 1); 191return Math.Min(_smallChange, LargeChange);

System\Windows\Forms\ToolTip\ToolTip.cs (8)

1575locationWeights[i] += Math.Abs((long)intersection.Width * intersection.Height); // Intersection is a weight 1588locationClippedAreas[i] = (Math.Abs((long)possibleLocations[i].Width) - Math.Abs((long)locationAreaWithinScreen.Width)) 1589* (Math.Abs((long)possibleLocations[i].Height) - Math.Abs((long)locationAreaWithinScreen.Height)); 1603locationWithinTopControlAreas[i] = Math.Abs((long)locationWithinTopControlRectangle.Height * locationWithinTopControlRectangle.Width); 2088? Math.Min(currentTooltipSize.Width - 2 * BalloonOffsetX, screen.WorkingArea.Width) 2089: Math.Min(currentTooltipSize.Width, screen.WorkingArea.Width);

System\ComponentModel\Design\CollectionEditor.CollectionEditorCollectionForm.cs (9)

23private static readonly double s_log10 = Math.Log(10); 211int c = Math.Max(2, _listBox.Items.Count); 214int charactersInNumber = ((int)(Math.Log(c - 1) / s_log10) + 1); 217w = Math.Max(w, (int)Math.Ceiling(sizeW.Width)); 227return (int)Math.Ceiling(size.Width) + w + pic + SystemInformation.BorderSize.Width * 4; 566int charactersInNumber = ((int)(Math.Log(maxC) / s_log10) + 1); // Luckily, this is never called if count = 0 569w = Math.Max(w, (int)Math.Ceiling(sizeW.Width));

System\ComponentModel\Design\DesignerActionPanel.cs (2)

381panelWidth = Math.Max(panelWidth, size.Width); 785editXPos = Math.Max(editXPos, line.GetEditRegionXPos());

System\ComponentModel\Design\DesignerActionPanel.EditorPropertyLine.cs (11)

95maxWidth = Math.Max(textSize.Width, maxWidth); 105listBox.Height = Math.Max(tm.tmHeight + 2, Math.Min(ListBoxMaximumHeight, listBox.PreferredHeight)); 106listBox.Width = Math.Max(maxWidth, EditRegionSize.Width); 335hostedControl.Width = Math.Max(hostedControl.Width, EditRegionSize.Width - 2); 345dropDownSize.Width = Math.Max(editorBounds.Width + 1, dropDownSize.Width); 347editorLocation.X = Math.Min(rectScreen.Right - dropDownSize.Width, // min = right screen edge clip 348Math.Max(rectScreen.X, editorLocation.X + editorBounds.Right - dropDownSize.Width)); // max = left screen edge clip 369dropDownSize.Width = Math.Max(editorBounds.Width + 1, dropDownSize.Width); 371editorLocation.X = Math.Min(rectScreen.Right - dropDownSize.Width, // min = right screen edge clip 372Math.Max(rectScreen.X, editorLocation.X - editorBounds.Width)); // max = left screen edge clip

System\ComponentModel\Design\DesignerActionPanel.EditorPropertyLine.FlyoutDialog.cs (2)

36int width = Math.Max(_hostedControl.Width, SystemInformation.MinimumWindowSize.Width); 37int height = Math.Max(_hostedControl.Height, SystemInformation.MinimizedWindowSize.Height);

System\ComponentModel\Design\DesignerActionPanel.PanelHeaderLine.cs (1)

72int newWidth = Math.Max(titleSize.Width, subtitleSize.Width) + 2 * PanelHeaderHorizontalPadding;

System\ComponentModel\Design\DesignerActionPanel.TextBoxPropertyLine.cs (2)

98int editRegionXPos = Math.Max(_editXPos, GetEditRegionXPos()); 100width = Math.Max(width, minimumWidth);

System\ComponentModel\Design\MultilineStringEditor.MultilineStringEditorUI.cs (7)

161requestedSize.Width = Math.Max(requestedSize.Width, MinimumSize.Width); 172int requestedDelta = Math.Min((requestedSize.Width - ClientSize.Width), maxDelta); 241(int)Math.Min(Math.Ceiling(WatermarkSize.Width * 1.75), workingArea.Width / 3), 242Math.Min(Font.Height * 10, workingArea.Height / 3)); 366_watermarkSize = new Size((int)Math.Ceiling(size.Width), (int)Math.Ceiling(size.Height));

System\ComponentModel\Design\SelectionService.cs (1)

262_contextKeyword = (short)Math.Min(count, s_selectionKeywords.Length - 1);

System\ComponentModel\Design\Serialization\CodeDomSerializerBase.cs (1)

1329int maxIndex = Math.Max(leftTypeIndex, rightTypeIndex);

System\Drawing\Design\CursorEditor.CursorUI.cs (1)

23ItemHeight = Math.Max(4 + Cursors.Default.Size.Height, Font.Height);

System\Windows\Forms\Design\Behavior\ContainerSelectorBehavior.cs (2)

179Size delta = new(Math.Abs(mouseLoc.X - InitialDragPoint.X), Math.Abs(mouseLoc.Y - InitialDragPoint.Y));

System\Windows\Forms\Design\Behavior\DragAssistanceManager.cs (22)

System\Windows\Forms\Design\Behavior\DragAssistanceManager.Line.cs (12)

53new(l1.X1, Math.Min(l1.Y1, l2.Y1), l1.X1, Math.Max(l1.Y1, l2.Y1)), 54new(l1.X1, Math.Min(l1.Y2, l2.Y2), l1.X1, Math.Max(l1.Y2, l2.Y2)) 62new(Math.Min(l1.X1, l2.X1), l1.Y1, Math.Max(l1.X1, l2.X1), l1.Y1), 63new(Math.Min(l1.X2, l2.X2), l1.Y1, Math.Max(l1.X2, l2.X2), l1.Y1) 87return new Line(l1.X1, Math.Min(l1.Y1, l2.Y1), l1.X2, Math.Max(l1.Y2, l2.Y2), l1.LineType); 93return new Line(Math.Min(l1.X1, l2.X1), l1.Y1, Math.Max(l1.X2, l2.X2), l1.Y2, l1.LineType);

System\Windows\Forms\Design\Behavior\ResizeBehavior.cs (13)

149rect.Width = Math.Max(rect.Width, _parentGridSize.Width); 150rect.Height = Math.Max(rect.Height, _parentGridSize.Height); 442return pixelsMoved - (integralHeight - (Math.Abs(pixelsMoved) % integralHeight)); 492if (Math.Abs(_initialPoint.X - mouseLoc.X) > DesignerUtils.MinDragSize.Width / 2 || Math.Abs(_initialPoint.Y - mouseLoc.Y) > DesignerUtils.MinDragSize.Height / 2) 549int minHeight = Math.Max(targetControl.MinimumSize.Height, MINSIZE); 550int minWidth = Math.Max(targetControl.MinimumSize.Width, MINSIZE); 679bounds.Height = Math.Max(minHeight, baseBounds.Height + pixelHeight); 697bounds.Height = Math.Max(minHeight, baseBounds.Height + yOffset); 704bounds.Y = Math.Min(baseBounds.Bottom - minHeight, baseBounds.Y - yOffset); 718bounds.Width = Math.Max(minWidth, baseBounds.Width + (!fRTL ? (mouseLoc.X - xOffset) : (xOffset - mouseLoc.X))); 732bounds.Width = Math.Max(minWidth, baseBounds.Width + xOffset); 739bounds.X = Math.Min(baseBounds.Right - minWidth, baseBounds.X - xOffset);

System\Windows\Forms\Design\Behavior\TableLayoutPanelBehavior.cs (3)

293newRightSize = Math.Max(rightStyleSize - delta, DesignerUtils.s_minimumSizeDrag); 301newLeftSize = Math.Max(leftStyleSize + delta, DesignerUtils.s_minimumSizeDrag); 344newAbsSize = Math.Max(absIndex == rightIndex ? curAbsStyleSize - delta : curAbsStyleSize + delta,

System\Windows\Forms\Design\Behavior\ToolboxItemSnapLineBehavior.cs (2)

166if (Math.Max(line.Y1, line.Y2) <= _lastRectangle.Top) 184if (Math.Max(line.X1, line.X2) <= _lastRectangle.Left)

System\Windows\Forms\Design\CommandSet.cs (3)

1724int shortIndex = Math.Max(0, shorterList.Count - 1); 1725int longIndex = Math.Max(0, longerList.Count - 1); 2766int lastIndex = Math.Max(0, n - 1);

System\Windows\Forms\Design\ComponentTray.cs (16)

1205_mouseDragWorkspace.X = Math.Min(start.X, end.X); 1206_mouseDragWorkspace.Y = Math.Min(start.Y, end.Y); 1207_mouseDragWorkspace.Width = Math.Abs(end.X - start.X); 1208_mouseDragWorkspace.Height = Math.Abs(end.Y - start.Y); 1340X = Math.Min(_mouseDragStart.X, e.X), 1341Y = Math.Min(_mouseDragStart.Y, e.Y), 1342Width = Math.Abs(e.X - _mouseDragStart.X), 1343Height = Math.Abs(e.Y - _mouseDragStart.Y) 1996rc.Width = Math.Max(_cxIcon, sz.Width) + 4 * _borderWidth + 2 * WhiteSpace; 2002rc.Height = Math.Max(_cyIcon, sz.Height) + 4 * _borderWidth; 2191minDrag.Width = Math.Max(minDrag.Width, minDblClick.Width); 2192minDrag.Height = Math.Max(minDrag.Height, minDblClick.Height); 2196(Math.Abs(_mouseDragLast.X - newPt.X) < minDrag.Width && 2197Math.Abs(_mouseDragLast.Y - newPt.Y) < minDrag.Height)) 2422if (Math.Abs(bounds.X - x) > parentGridSize.Width || Math.Abs(bounds.Y - y) > parentGridSize.Height)

System\Windows\Forms\Design\ControlDesigner.cs (6)

301return new Point(Math.Abs(nativeOffset.X - offset.X), nativeOffset.Y - offset.Y); 1395minDrag.Width = Math.Max(minDrag.Width, minDblClick.Width); 1396minDrag.Height = Math.Max(minDrag.Height, minDblClick.Height); 1400(Math.Abs(_mouseDragLast.X - x) < minDrag.Width && 1401Math.Abs(_mouseDragLast.Y - y) < minDrag.Height)) 2275Math.Max(SystemInformation.ToolWindowCaptionHeight - SystemInformation.BorderSize.Height - 2, Control.Font.Height),

System\Windows\Forms\Design\DataGridViewColumnCollectionDialog.cs (4)

805_selectedColumns.SelectedIndex = Math.Min(0, _selectedColumns.Items.Count - 1); 834_selectedColumns.SelectedIndex = Math.Min(_selectedColumns.Items.Count - 1, selectedIndex); 881_selectedColumns.SelectedIndex = Math.Min(selectedIndex, _selectedColumns.Items.Count - 1); 1161maxItemWidth = Math.Max(maxItemWidth, itemWidth);

System\Windows\Forms\Design\DataGridViewColumnDesigner.cs (1)

131value = Math.Max(col.MinimumWidth, value);

System\Windows\Forms\Design\DataGridViewColumnTypeEditor.Picker.cs (4)

50width = Math.Max(width, Size.Ceiling(g.MeasureString(item.ToString(), _typesListBox.Font)).Width); 63width = Math.Max(width, MinimumWidth); 68height = Math.Max(height, MinimumHeight); 116Width = Math.Max(Width, PreferredWidth + (SystemInformation.VerticalScrollBarWidth * 2));

System\Windows\Forms\Design\DesignBindingPicker.cs (5)

575Width = Math.Max(Width, _treeViewCtrl is null ? 0 : _treeViewCtrl.PreferredWidth + (SystemInformation.VerticalScrollBarWidth * 2)); 1666width = Math.Max(width, s_minimumWidth); 1671height = Math.Max(height, s_minimumHeight); 2029maxWidth = Math.Max(w, maxWidth); 2032maxWidth = Math.Max(maxWidth, GetMaxItemWidth(node.Nodes));

System\Windows\Forms\Design\DesignerUtils.cs (6)

146s_minDragSize.Width = Math.Max(minDrag.Width, minDblClick.Width); 147s_minDragSize.Height = Math.Max(minDrag.Height, minDblClick.Height); 390Math.Max(control.Width, s_minimumControlBitmapSize), 391Math.Max(control.Height, s_minimumControlBitmapSize), 423Math.Max(control.Width, s_minimumControlBitmapSize), 424Math.Max(control.Height, s_minimumControlBitmapSize),

System\Windows\Forms\Design\DockEditor.DockUI.cs (4)

236? _leftRightOrder[Math.Max(i - 1, 0)] 237: _leftRightOrder[Math.Min(i + 1, maxI)]; 278? _upDownOrder[Math.Max(i - 1, 0)] 279: _upDownOrder[Math.Min(i + 1, maxI)];

System\Windows\Forms\Design\FlowLayoutPanelDesigner .cs (3)

69private readonly int _maxIBarWidth = Math.Max(IBarHalfSize, (IBarHatWidth - 1) / 2); 484if (Math.Abs(point1.Y - point2.Y) <= MinIBar) 523if (Math.Abs(point1.X - point2.X) <= MinIBar)

System\Windows\Forms\Design\FormatControl.cs (4)

377minWidth = Math.Max(minWidth, secondRowLabel.Width); 378minHeight = Math.Max(minHeight, secondRowLabel.Height); 381minWidth = Math.Max(minWidth, secondRowLabel.Width); 382minHeight = Math.Max(minHeight, secondRowLabel.Height);

System\Windows\Forms\Design\FormDocumentDesigner.cs (4)

66return new Size((int)Math.Round(real.Width), (int)Math.Round(real.Height)); 269Size newVar = new((int)Math.Round(newVarF.Width), (int)Math.Round(newVarF.Height));

System\Windows\Forms\Design\ParentControlDesigner.cs (4)

2032Rectangle paintRect = new(Math.Min(displayRect.X, clientRect.X), 2033Math.Min(displayRect.Y, clientRect.Y), 2034Math.Max(displayRect.Width, clientRect.Width), 2035Math.Max(displayRect.Height, clientRect.Height));

System\Windows\Forms\Design\SelectionUIHandler.cs (2)

454Size size = new(Math.Max(MinControlWidth, newBounds.Width), Math.Max(MinControlHeight, newBounds.Height));

System\Windows\Forms\Design\SelectionUIService.cs (2)

631Math.Abs(screenCoord.X - _mouseDragAnchor.X) < minDragSize.Width && 632Math.Abs(screenCoord.Y - _mouseDragAnchor.Y) < minDragSize.Height)

System\Windows\Forms\Design\TableLayoutPanelDesigner.cs (6)

1202_rowCountBeforeAdd = Math.Max(0, Table.GetRowHeights().Length); // don't want negative 1203_colCountBeforeAdd = Math.Max(0, Table.GetColumnWidths().Length); 1237bool fullTable = (totalArea - 1) >= (Math.Max(1, _colCountBeforeAdd) * Math.Max(1, _rowCountBeforeAdd)); 1342_rowCountBeforeAdd = Math.Max(0, Table.GetRowHeights().Length); // don't want negative 1343_colCountBeforeAdd = Math.Max(0, Table.GetColumnWidths().Length);

System\Windows\Forms\Design\ToolStripCollectionEditor.ToolStripItemEditorForm.cs (5)

441_newItemTypes.ItemHeight = Math.Max(s_iconHeight, Font.Height); 551itemWidth = (int)Math.Max(itemWidth, _newItemTypes.ItemHeight + 1 641e.ItemHeight = Math.Max(s_iconHeight + separator, measureFont.Height + separator) + 2 * s_imagePaddingY; 951index = Math.Max(0, Math.Min(index, _listBoxItems.Items.Count - 1));

System\Windows\Forms\Design\ToolStripDesigner.cs (2)

1037itemIndex = Math.Min(ToolStrip.Items.Count - 1, itemIndex); 1038itemIndex = Math.Max(0, itemIndex);

System\Windows\Forms\Design\ToolStripDesignerUtils.cs (1)

547s_bitsPerPixel = (short)Math.Min(s.BitsPerPixel, s_bitsPerPixel);

System\Windows\Forms\Design\ToolStripItemBehavior.cs (2)

405int startIndexOfSelection = Math.Min(parent.Items.IndexOf(selectedItem), parent.Items.IndexOf(glyphItem)); 406int endIndexOfSelection = Math.Max(parent.Items.IndexOf(selectedItem), parent.Items.IndexOf(glyphItem));

System\Windows\Forms\Design\ToolStripKeyboardHandlingService.cs (2)

691int endIndexOfSelection = Math.Max(0, parent.Items.IndexOf(item)); 736int endIndexOfSelection = Math.Max(startIndexOfSelection, count - 2);

System\Windows\Forms\Design\ToolStripMenuItemDesigner.cs (4)

1909itemIndex = Math.Min(ownerItem.DropDownItems.Count - 1, itemIndex); 1910itemIndex = Math.Max(0, itemIndex); 2534int maxIndex = Math.Max(ownerDropDown.Items.IndexOf(oldSelection), ownerDropDown.Items.IndexOf(MenuItem)); 2535int minIndex = Math.Min(ownerDropDown.Items.IndexOf(oldSelection), ownerDropDown.Items.IndexOf(MenuItem));

System\Windows\Forms\Automation\UiaTextRange.cs (13)

195End = Math.Min(Math.Max(End, Start + 1), text.Length); 247End = Math.Min(Math.Max(End, Start + 1), text.Length); 364Rectangle endlineRectangle = new(endlinePoint.X, endlinePoint.Y + 2, UiaTextProvider.EndOfLineWidth, Math.Abs(_provider.Logfont.lfHeight) + 1); 438maxLength = maxLength >= 0 ? Math.Min(Length, maxLength) : Length; 597: Math.Max(0, _provider.GetLineFromCharIndex(End) - _provider.LinesPerPage + 1); 745int lineHeight = Math.Abs(_provider.Logfont.lfHeight); 889return Math.Round((double)(-logfont.lfHeight) * 72 / lpy); 936moved = Math.Min(count, limit - index); 975moved = Math.Min(count, lineMax - line - 1); 1051moved = Math.Max(count, -oneBasedIndex); 1086int actualCount = Math.Max(count, -line);

System\Windows\Forms\Internals\ScaleHelper.cs (4)

242textScale = Math.Clamp(textScale, MinTextScaleValue, MaxTextScaleValue); 261internal static int ScaleToPercent(int value, double percent) => Math.Max(1, (int)Math.Round(value * percent)); 276return (int)Math.Round(scalingFactor * logicalValue);

System\Windows\Forms\Internals\UnicodeCharBuffer.cs (1)

51int count = Math.Min(s.Length, _buffer.Length - _offset);

Windows\Win32\PInvoke.GetModuleFileNameLongPath.cs (1)

41buffer.EnsureCapacity(Math.Min(buffer.Length * 2, short.MaxValue));

Windows\Win32\Pinvoke.RegLoadMUIString.cs (1)

39? buffer[..Math.Max((int)(bytes / sizeof(char)) - 1, 0)].ToString()

GdiHelper.cs (2)

39=> (int)Math.Round((double)((long)LogicalPixelsX * himetric) / HiMetricPerInch, 0); 45=> (int)Math.Round((double)((long)LogicalPixelsY * himetric) / HiMetricPerInch, 0);

DpiHelperTests.cs (3)

17int expected = (int)Math.Round(value * (ScaleHelper.InitialSystemDpi / (double)ScaleHelper.OneHundredPercentLogicalDpi)); 27(int)Math.Round(value.Width * (ScaleHelper.InitialSystemDpi / (double)ScaleHelper.OneHundredPercentLogicalDpi)), 28(int)Math.Round(value.Height * (ScaleHelper.InitialSystemDpi / (double)ScaleHelper.OneHundredPercentLogicalDpi)));

System\Windows\Forms\AccessibleObjects\ComboBox.ComboBoxItemAccessibleObjectTests.cs (1)

322int visibleItemsCount = (int)Math.Ceiling((double)dropDownRect.Height / comboBox.ItemHeight);

System\Windows\Forms\ToolStripDropDownTests.cs (2)

1933expected.X = Math.Max(expected.X, SystemInformation.WorkingArea.X); 1934expected.Y = Math.Max(expected.Y, SystemInformation.WorkingArea.Y);

ButtonTests.cs (6)

263Point virtualPoint = new((int)Math.Round(65535.0 / horizontalResolution * centerOnScreen.X), 264(int)Math.Round(65535.0 / verticalResolution * centerOnScreen.Y)); 299Point virtualPoint = new((int)Math.Round(65535.0 / horizontalResolution * centerOnScreen.X), (int)Math.Round(65535.0 / verticalResolution * centerOnScreen.Y)); 300Point virtualPoint1 = new((int)Math.Round(65535.0 / horizontalResolution * centerOnScreen1.X), (int)Math.Round(65535.0 / verticalResolution * centerOnScreen1.Y));

Dpi\DpiMessageHelper.cs (2)

25(int)Math.Round(control.Width * factor), 26(int)Math.Round(control.Height * factor));

Infra\ControlTestBase.cs (2)

185(int)Math.Ceiling((65535.0 / (primaryMonitor.Width - 1)) * point.X), 186(int)Math.Ceiling((65535.0 / (primaryMonitor.Height - 1)) * point.Y));

Infra\DataCollectionService.cs (1)

221testName = testName[..Math.Max(0, testName.Length - (path.Length - MaxPath))];

Infra\ScreenRecordService.cs (3)

296lastChangedColumn = Math.Max(lastChangedColumn, column); 547for (ReadOnlySpan<byte> remaining = bytes; !remaining.IsEmpty; remaining = remaining[Math.Min(buffer.Length, remaining.Length)..]) 549ReadOnlySpan<byte> current = remaining[..Math.Min(buffer.Length, remaining.Length)];

System\Windows\Input\Manipulations\DoubleUtil.cs (1)

157return Math.Abs(d) <= DBL_EPSILON;

System\Windows\Input\Manipulations\InertiaProcessor2D.cs (9)

614initialTranslationX.AbsoluteOffset = Math.Abs(desiredTranslationXY.X); 615initialTranslationY.AbsoluteOffset = Math.Abs(desiredTranslationXY.Y); 625initialTranslationX.AbsoluteDeceleration = Math.Abs(desiredDecelerationXY.X); 626initialTranslationY.AbsoluteDeceleration = Math.Abs(desiredDecelerationXY.Y); 693state.Duration = 2 * Math.Abs(state.Offset / state.InitialVelocity); 702state.AbsoluteDeceleration = Math.Abs(state.InitialVelocity) / state.Duration; 719state.Duration = Math.Abs(state.InitialVelocity) / state.AbsoluteDeceleration; 1068result = new VectorD(Math.Abs(baseVector.X * scale), 1069Math.Abs(baseVector.Y * scale));

System\Windows\Input\Manipulations\ManipulationSequence.cs (16)

893double oldAngle = Math.Atan2(oldVectorForRotationCalc.Y, oldVectorForRotationCalc.X); 894double newAngle = Math.Atan2(newVectorForRotationCalc.Y, newVectorForRotationCalc.X); 896if (delta > Math.PI) 897delta -= Math.PI * 2.0; 898if (delta < -Math.PI) 899delta += Math.PI * 2.0; 952torqueFactor = (float)Math.Min(1.0, Math.Pow(oldVector.Length / settings.Pivot.Radius, singleManipulatorTorqueFactor)); 1163float value2 = value + (float)(2 * Math.PI); 1164float value3 = value - (float)(2 * Math.PI); 1165float delta = Math.Abs(baseValue - value); 1166if (Math.Abs(baseValue - value2) < delta) 1170else if (Math.Abs(baseValue - value3) < delta) 1339smoothingLevel = Math.Max(0, Math.Min(1, smoothingLevel)); 1342int newHistoryLength = (int)Math.Round(smoothingLevel * MaxHistoryLength);

System\Windows\Input\Manipulations\VectorD.cs (1)

360return Math.Sqrt(LengthSquared);

System\Windows\Input\Manipulations\VectorF.cs (7)

345return (float)Math.Sqrt(LengthSquared); 410double angle = Math.Atan2(vector2.y, vector2.x) - Math.Atan2(vector1.y, vector1.x); 411if (angle > Math.PI) 413angle -= Math.PI * 2.0; 415else if (angle < -Math.PI) 417angle += Math.PI * 2.0;

src\Microsoft.DotNet.Wpf\src\Shared\MS\Utility\FrugalList.cs (1)

1546int newCapacity = Math.Max(newCount + (newCount >> 2), MINSIZE);

src\RoslynAnalyzers\Utilities\Compiler\SmallDictionary.cs (3)

178return 1 + Math.Max(a, b); 303Math.Abs(a - b) >= 2) 308return 1 + Math.Max(a, b);

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.AssemblyMetricData.cs (1)

59depthOfInheritance = Math.Max(child.DepthOfInheritance.GetValueOrDefault(), depthOfInheritance);

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.FieldMetricData.cs (4)

47double computationalComplexityVolume = Math.Max(0.0, Math.Log(computationalComplexityMetrics.Volume)); //avoid Log(0) = -Infinity 48double logEffectiveLinesOfCode = Math.Max(0.0, Math.Log(computationalComplexityMetrics.EffectiveLinesOfCode)); //avoid Log(0) = -Infinity

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.MethodMetricData.cs (4)

58double computationalComplexityVolume = Math.Max(0.0, Math.Log(computationalComplexityMetrics.Volume)); //avoid Log(0) = -Infinity 59double logEffectiveLinesOfCode = Math.Max(0.0, Math.Log(computationalComplexityMetrics.EffectiveLinesOfCode)); //avoid Log(0) = -Infinity

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.NamedTypeMetricData.cs (4)

175double logAvgComputationalComplexityVolume = Math.Max(0.0, Math.Log(avgComputationalComplexityVolume)); //avoid Log(0) = -Infinity 176double logAvgLinesOfCode = Math.Max(0.0, Math.Log(avgEffectiveLinesOfCode)); //avoid Log(0) = -Infinity

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.NamespaceMetricData.cs (1)

57depthOfInheritance = Math.Max(child.DepthOfInheritance.GetValueOrDefault(), depthOfInheritance);

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\ComputationalComplexityMetrics.cs (2)

437=> Length * Math.Max(0.0, Math.Log(Vocabulary, 2));

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (3)

33private static int RoundMetricValue(double value) => (int)Math.Round(value, 0); 37maintIndex = Math.Max(0.0, maintIndex); 93var additionalNewLines = Math.Max(0, GetNewlineCount(declSyntax.GetLeadingTrivia(), leading: true) + GetNewlineCount(declSyntax.GetTrailingTrivia(), leading: false) - 1);

src\RoslynAnalyzers\Utilities\Compiler\SmallDictionary.cs (3)

178return 1 + Math.Max(a, b); 303Math.Abs(a - b) >= 2) 308return 1 + Math.Max(a, b);

MS\Internal\AutomationProxies\WindowsEditBox.cs (4)

364clientLocation.x = Math.Max(clientLocation.x, clientRect.left); 365clientLocation.x = Math.Min(clientLocation.x, clientRect.right); 366clientLocation.y = Math.Max(clientLocation.y, clientRect.top); 367clientLocation.y = Math.Min(clientLocation.y, clientRect.bottom);

MS\Internal\AutomationProxies\WindowsEditBoxRange.cs (13)

127End = Math.Min(Math.Max(End, Start + 1), text.Length); 161End = Math.Min(Math.Max(End, Start + 1), text.Length); 295return text.Substring(Start, maxLength >= 0 ? Math.Min(Length, maxLength) : Length); 469Math.Max(0, _provider.LineFromChar(End) - _provider.LinesPerPage() + 1); 654int height = Math.Abs(_provider.GetLogfont().lfHeight);; 681ArrayList rects = new ArrayList(Math.Max(endLine - startLine + 1, 0)); 776return Math.Round((double)(-logfont.lfHeight) * 72 / lpy); 823moved = Math.Min(count, limit - index); 868moved = Math.Min(count, lineMax - line - 1); 936moved = Math.Max(count, -oneBasedIndex); 981int actualCount = Math.Max(count, -line);

MS\Internal\AutomationProxies\WindowsListView.cs (2)

1043int rowCount = (int) System.Math.Ceiling (((double) itemCount) / columnCount); 1689int future = (int) Math.Round (((si.nMax - deltaPage) - si.nMin) * fScrollPos / 100.0 + si.nMin);

MS\Internal\AutomationProxies\WindowsListViewItem.cs (1)

946clickPoint.x = Math.Min ((itemRectangle.left + 5), (itemRectangle.left + itemRectangle.right) / 2);

MS\Internal\AutomationProxies\WindowsMenu.cs (1)

2315cMoves = Math.Abs (cMoves);

MS\Internal\AutomationProxies\WindowsRichEditRange.cs (4)

77_range.SetRange(Math.Max(charRange.Start, paraRange.Start), Math.Min(charRange.End, paraRange.End)); 160int start = Math.Max(_range.Start, visibleRange.Start); 161int end = Math.Min(_range.End, visibleRange.End);

MS\Internal\AutomationProxies\WindowsScroll.cs (1)

305int newPos = (int) Math.Round (((si.nMax - delta) - si.nMin) * fScrollPos / 100.0 + si.nMin);

MS\Internal\AutomationProxies\WindowsTab.cs (1)

509int newPos = (int) Math.Round ((maxPos - minPos) * horizontalPercent / 100) + minPos;

src\Microsoft.DotNet.Wpf\src\Shared\MS\Win32\HandleCollector.cs (1)

169handleCount = Math.Max(0, handleCount);

src\Microsoft.DotNet.Wpf\src\Shared\MS\Win32\NativeMethodsCLR.cs (2)

2367int count = Math.Min(bytes.Length, buffer.Length - offset); 2423int count = Math.Min(s.Length, buffer.Length - offset);

src\Compilers\Server\VBCSCompiler\NamedPipeClientConnectionHost.cs (1)

69var listenCount = Math.Min(4, Environment.ProcessorCount);

System\Windows\VectorTests.cs (9)

50yield return new object[] { 1, 2, Math.Sqrt(5) }; 51yield return new object[] { 1.1, 2.2, Math.Sqrt(6.05) }; 52yield return new object[] { -1.1, -2.2, Math.Sqrt(6.05) }; 53yield return new object[] { double.MaxValue, double.MaxValue, Math.Sqrt(double.PositiveInfinity) }; 62Assert.Equal(Math.Sqrt(vector.LengthSquared), vector.Length, precision: 5); 323Assert.Equal(1 / Math.Sqrt(5), vector.X, precision: 5); 324Assert.Equal(2 / Math.Sqrt(5), vector.Y, precision: 5); 334Assert.Equal(-1 / Math.Sqrt(5), vector.X, precision: 5); 335Assert.Equal(-2 / Math.Sqrt(5), vector.Y, precision: 5);

System\Windows\Integration\ElementHost.cs (2)

315int maxWidth = Math.Min(priorMaxSize.Width, maxElementSize.Width); 316int maxHeight = Math.Min(priorMaxSize.Height, maxElementSize.Height);

System\Windows\Integration\HostUtils.cs (7)

72Math.Max(size1.Width, size2.Width), 73Math.Max(size1.Height, size2.Height)); 79Math.Min(size1.Width, size2.Width), 80Math.Min(size1.Height, size2.Height)); 266(int)Math.Ceiling(element.ActualWidth), 267(int)Math.Ceiling(element.ActualHeight), 392return Math.Abs(value) < 10d * DBL_EPSILON;

System\Windows\Integration\WindowsFormsHost.cs (4)

248returnSize.Width = Math.Min(returnSize.Width, constraint.Width); 249returnSize.Height = Math.Min(returnSize.Height, constraint.Height); 283returnSize.Width = Math.Min(returnSize.Width, finalSize.Width); 284returnSize.Height = Math.Min(returnSize.Height, finalSize.Height);

ChartControl.cs (2)

22double yValue = (1.0 + Math.Sin(angle / 180.0 * Math.PI)) * 10.0;

CurrentDPILabel.cs (1)

34Text = $"Current scaling is {(int)Math.Round((DeviceDpi / 96.0) * 100)}%";

MainForm.cs (1)

295((int)Math.Ceiling((overarchingFlowLayoutPanel.Controls.Count + 1) / 3.0) * (biggestButton.Height + (padding * 2)))

MenuStripAndCheckedListBox.cs (2)

18currentDpiLabel.Text = $"Current scaling = {(int)Math.Round((DeviceDpi / 96.0) * 100)}%"; 23currentDpiLabel.Text = $"Current scaling = {(int)Math.Round((DeviceDpi / 96.0) * 100)}%";

TrackBars.cs (4)

73trackBar1.Minimum = (int)Math.Max(numericMinimum.Value, int.MinValue); 75numericFrequency.Maximum = (int)Math.Min(numericMaximum.Value - numericMaximum.Minimum, int.MaxValue); 86trackBar1.Maximum = (int)Math.Min(numericMaximum.Value, int.MaxValue); 88numericFrequency.Maximum = (int)Math.Min(numericMaximum.Value - numericMaximum.Minimum, int.MaxValue);

EqualityAsserts.cs (26)

Sdk\AssertHelper.cs (3)

215 var start = Math.Max(index - 20, 0); 216 var end = Math.Min(start + 41, value.Length); 217 start = Math.Max(end - 41, 0);

Sdk\CollectionTracker.cs (7)

592 var startIndex = Math.Max(0, (mismatchedIndex ?? 0) - MAX_ENUMERABLE_LENGTH_HALF); 593 var endIndex = Math.Min(span.Length - 1, startIndex + ArgumentFormatter.MAX_ENUMERABLE_LENGTH - 1); 594 startIndex = Math.Max(0, endIndex - ArgumentFormatter.MAX_ENUMERABLE_LENGTH + 1); 734 var printLength = Math.Min(currentIndex + 1, ArgumentFormatter.MAX_ENUMERABLE_LENGTH); 777 startIndex = Math.Max(0, (mismatchedIndex ?? 0) - MAX_ENUMERABLE_LENGTH_HALF); 786 startIndex = Math.Max(0, endIndex - ArgumentFormatter.MAX_ENUMERABLE_LENGTH + 1); 848 var itemIndex = Math.Max(0, CurrentIndex - ArgumentFormatter.MAX_ENUMERABLE_LENGTH + 1);