IsNaN

FrameworkFork\Microsoft.CodeDom\Microsoft\CSharpCodeProvider.cs (1)

FrameworkFork\Microsoft.Xml\Xml\schema\DatatypeImplementation.cs (1)

3796if (float.IsInfinity(value) || float.IsNaN(value))

BindConverter.cs (2)

989if (float.IsInfinity(converted) || float.IsNaN(converted)) 1014if (float.IsInfinity(converted) || float.IsNaN(converted))

ArraySortHelper.cs (1)

1244|| (typeof(TKey) == typeof(float) && float.IsNaN((float)(object)keys[i]))

Writers\CSharp\CSDeclarationWriter.Attributes.cs (1)

289else if (float.IsNaN(val))

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

1240|| (typeof(TKey) == typeof(float) && float.IsNaN((float)(object)keys[i]))

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

1240|| (typeof(TKey) == typeof(float) && float.IsNaN((float)(object)keys[i]))

Internal\ArraySortHelper.cs (1)

1240|| (typeof(TKey) == typeof(float) && float.IsNaN((float)(object)keys[i]))

Lowering\LocalRewriter\LocalRewriter.PatternLocalRewriter.cs (1)

404input.Type.SpecialType == SpecialType.System_Single && float.IsNaN(value.SingleValue))

Utilities\ValueSetFactory.SingleTC.cs (4)

33Debug.Assert(!float.IsNaN(value)); 73return left == right || float.IsNaN(left) && float.IsNaN(right); // for our purposes, NaNs are equal 95float.IsNaN(value) ? "NaN" :

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\ExpressionGenerator.cs (1)

205if (float.IsNaN(value))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\ExpressionGenerator.cs (1)

205if (float.IsNaN(value))

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

1240|| (typeof(TKey) == typeof(float) && float.IsNaN((float)(object)keys[i]))

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

1240|| (typeof(TKey) == typeof(float) && float.IsNaN((float)(object)keys[i]))

RealParserTests.cs (1)

561if (float.IsInfinity(d) || float.IsNaN(d)) return;

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

1240|| (typeof(TKey) == typeof(float) && float.IsNaN((float)(object)keys[i]))

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

1240|| (typeof(TKey) == typeof(float) && float.IsNaN((float)(object)keys[i]))

Microsoft\CSharp\RuntimeBinder\BinderHelper.cs (1)

78else if (o.Value is float && float.IsNaN((float)o.Value))

Layouts\Flex.cs (10)

490 if (float.IsNaN(child.Frame[layout.frame_size_i])) 495 if (float.IsNaN(child.Frame[layout.frame_size2_i])) 518 if (!float.IsNaN(val)) 551 if (!float.IsNaN(child_size2) && child_size2 + child.MarginThickness(!layout.vertical) > layout.line_dim) 623 if (float.IsNaN(child.Frame[layout.frame_size2_i])) 898 !float.IsNaN(val) ? val : (!float.IsNaN(pos1) && !float.IsNaN(pos2) ? dim - pos2 - pos1 : 0); 901 !float.IsNaN(pos1) ? pos1 : (!float.IsNaN(pos2) ? dim - size - pos2 : 0);

Layout\FlexExtensions.cs (2)

23 if (widthConstraint < 0 && !float.IsNaN(parent.Width)) 25 if (heightConstraint < 0 && !float.IsNaN(parent.Height))

DatasetDimensions\DatasetDimensionsUtil.cs (1)

40if (Single.IsNaN(value))

Sweepers\Parameters.cs (1)

129Runtime.Contracts.Assert(!float.IsNaN(value));

Utils.cs (1)

105if (Single.IsNaN(f.GetValueOrDefault()))

Utilities\DoubleParser.cs (1)

94Contracts.Assert(res != Result.Empty || ((flags & OptionFlags.EmptyAsNaN) == 0 && value == 0) || Single.IsNaN(value));

Utilities\MathUtils.cs (5)

555if (float.IsNaN(x)) 594if (float.IsNaN(x)) 634if (float.IsNaN(x)) 716while (ivMin < ivLim && float.IsNaN(src[ivMin])) 724Contracts.Assert(!float.IsNaN(src[ivLim - 1]));

Utilities\Utils.cs (2)

323Contracts.Assert(!float.IsNaN(value)); 331Contracts.Assert(!float.IsNaN(input[mid]));

Utilities\VBufferUtils.cs (1)

28if (Single.IsNaN(values[i]))

UnitTests\TestEntryPoints.cs (20)

Data\Conversion.cs (3)

766private bool IsNA(in R4 src) => R4.IsNaN(src); 771private bool HasNA(in VBuffer<R4> src) { var srcValues = src.GetValues(); for (int i = 0; i < srcValues.Length; i++) { if (R4.IsNaN(srcValues[i])) return true; } return false; } 924public void Convert(in R4 src, ref SB dst) { ClearDst(ref dst); if (R4.IsNaN(src)) dst.AppendFormat(CultureInfo.InvariantCulture, "{0}", "?"); else dst.AppendFormat(CultureInfo.InvariantCulture, "{0:R}", src); }

EntryPoints\EntryPointNode.cs (1)

777if (!float.IsNaN(Cost))

Evaluators\AnomalyDetectionEvaluator.cs (2)

244Contracts.Assert(!Single.IsNaN(label)); 531if (Single.IsNaN(label))

Evaluators\BinaryClassifierEvaluator.cs (6)

519if (!Single.IsNaN(prob)) 654if (Single.IsNaN(_label)) 664if (!Single.IsNaN(prob)) 1233if (Single.IsNaN(prob) || Single.IsNaN(label)) 1243return Single.IsNaN(val) ? false : val > _threshold;

Evaluators\ClusteringEvaluator.cs (1)

423if (Single.IsNaN(label))

Evaluators\MulticlassClassificationEvaluator.cs (2)

433if (float.IsNaN(label)) 787if (float.IsNaN(label))

Evaluators\RankingEvaluator.cs (2)

492if (Single.IsNaN(score)) 506if (Single.IsNaN(_currentQueryWeight))

Evaluators\RegressionEvaluator.cs (1)

157return float.IsNaN(score);

Evaluators\RegressionEvaluatorBase.cs (1)

222if (float.IsNaN(label))

Prediction\Calibrator.cs (4)

1277if (float.IsNaN(output)) 1410if (weight == 0 || float.IsNaN(score)) 1773if (float.IsNaN(output)) 2086if (float.IsNaN(output))

Transforms\Hashing.cs (3)

545=> float.IsNaN(value) ? 0 : (Hashing.MixHash(Hashing.MurmurRound(seed, FloatUtils.GetBits(value == 0 ? 0 : value))) & mask) + 1; 549=> float.IsNaN(value) ? 0 : (Hashing.MixHash(Hashing.MurmurRound(seed, FloatUtils.GetBits(value == 0 ? 0 : value)), sizeof(float)) & mask) + 1; 557if (float.IsNaN(value))

Transforms\NormalizeColumnSng.cs (13)

134Contracts.CheckDecode(!TFloat.IsNaN(scale)); 143Contracts.CheckDecode(!TFloat.IsNaN(offset)); 170Contracts.CheckDecode(!TFloat.IsNaN(scale)); 179Contracts.CheckDecode(!TFloat.IsNaN(offset)); 1559Contracts.Assert(!TFloat.IsNaN(min)); 1560Contracts.Assert(!TFloat.IsNaN(max)); 1584Contracts.Assert(!TFloat.IsNaN(min)); 1585Contracts.Assert(!TFloat.IsNaN(max)); 1660if (TFloat.IsNaN(input)) 1671if (TFloat.IsNaN(input)) 2054_values.RemoveAll(TFloat.IsNaN); 2131_values[i].RemoveAll(TFloat.IsNaN); 2154return !TFloat.IsNaN(colValue);

OutputCombiners\BaseAverager.cs (2)

57if (!Single.IsNaN(src[i])) 68if (!Single.IsNaN(src[i]))

OutputCombiners\BaseStacking.cs (1)

163return CreateDataView(env, ch, data, maps, models, x => float.IsNaN(x) ? 0 : (uint)(x + 1));

FastTree.cs (1)

1683if (float.IsNaN(kv.Value))

Common.cs (1)

337Assert.False(float.IsNaN(array[i]));

LightGbmMulticlassTrainer.cs (2)

281if (float.IsNaN(labelColumn)) 313if (float.IsNaN(labels[i]))

LightGbmTrainerBase.cs (2)

791if (float.IsNaN(cursor.Weight)) 831if (float.IsNaN(labels[i]))

TestPredictors.cs (2)

946if (scores.All(s => !float.IsNaN(s))) 955if (float.IsNaN(sum))

ResultProcessor.cs (1)

1156if (float.IsNaN(kvp.Value.MetricValue) && kvp.Value.AllValues != null)

Optimizer\Optimizer.cs (1)

472if (float.IsNaN(alpha) || float.IsInfinity(alpha))

Standard\LogisticRegression\LogisticRegression.cs (1)

207Contracts.Check(!float.IsNaN(datumLoss), "Unexpected NaN");

Standard\MulticlassClassification\OneVersusAllTrainer.cs (1)

755if (float.IsNaN(value))

Standard\Simple\SimpleTrainers.cs (3)

361Host.Check(!float.IsNaN(prob)); 376Host.CheckDecode(!float.IsNaN(_prob)); 399Contracts.Assert(!float.IsNaN(_prob));

Parameters.cs (1)

137Contracts.Check(!float.IsNaN(value));

SvmLightTests.cs (1)

266Assert.True(float.IsNaN(label));

TrainerEstimators\MatrixFactorizationTests.cs (2)

367Assert.True(!float.IsNaN(pred.Score)); 386Assert.True(float.IsNaN(pred.Score));

TrainerEstimators\TreeEstimators.cs (4)

567if (float.IsNaN((float)nativeResult1[j + i * _classNumber])) 603if (float.IsNaN((float)nativeResult1[j + i * _classNumber])) 637if (float.IsNaN((float)firstNativeResult1[j + i * _classNumber])) 639if (float.IsNaN((float)secondNativeResult1[j + i * _classNumber]))

AdaptiveSingularSpectrumSequenceModeler.cs (4)

1105if (Single.IsNaN(input)) 1225if (!Single.IsNaN(val)) 1272if (Single.IsNaN(leftSingularVecs[i])) 1569if (!Single.IsNaN(val))

MovingAverageTransform.cs (6)

124if (Single.IsNaN(input)) 152if (!Single.IsNaN(input)) 193if (Single.IsNaN(lastDropped)) 204Contracts.Assert(FloatUtils.IsFinite(lastDropped) || Single.IsNaN(lastDropped)); 216if (!Single.IsNaN(currentSum) && !FloatUtils.IsFinite(currentSum)) 228Contracts.Assert(FloatUtils.IsFinite(currentSum) || Single.IsNaN(currentSum));

TrajectoryMatrix.cs (2)

504_ectx.Assert(!Single.IsNaN(sigma)); 575_ectx.Assert(!Single.IsNaN(sigma));

ObjectDetectionTests.cs (2)

85Assert.True(!float.IsNaN(metrics.MAP50)); 86Assert.True(!float.IsNaN(metrics.MAP50_95));

Expression\BuiltinFunctions.cs (2)

39return R4.IsNaN((R4)v); 835return R4.IsNaN(a);

Expression\LambdaBinder.cs (13)

595if (!R4.IsNaN(v)) 601if (R4.IsNaN(v)) 607if (R4.IsNaN(v)) 615if (R4.IsNaN(v)) 627if (R4.IsNaN(v)) 631if (R4.IsNaN(v)) 637if (R4.IsNaN(v)) 645if (R4.IsNaN(v)) 773return !R4.IsNaN(v1) ? v1 : v2; 1783(a,b) => { var x = Cast<R4>(a); var y = Cast<R4>(b); if (x == y) return true; if (!R4.IsNaN(x) && !R4.IsNaN(y)) return false; return null; }, 1797(a,b) => { var x = Cast<R4>(a); var y = Cast<R4>(b); if (x == y) return false; if (!R4.IsNaN(x) && !R4.IsNaN(y)) return true; return null; },

Expression\Printer.cs (1)

256if (R4.IsNaN(x))

LearnerFeatureSelection.cs (1)

239if (float.IsNaN(score))

MissingValueIndicatorTransform.cs (3)

279if (float.IsNaN(input)) 312if (float.IsNaN(val)) 340if (float.IsNaN(val))

MutualInformationFeatureSelection.cs (2)

822if (!Single.IsNaN(val)) 832dst = Single.IsNaN(src) ? offset : offset + 1 + bounds.FindIndexSorted(src);

SvmLight\SvmLightSaver.cs (1)

142writer.Write(float.IsNaN(lab) ? 0 : (lab > 0 ? 1 : -1));

System\Windows\Media\MILUtilities.cs (10)

AlphaFlattener\Utility.cs (5)

2249if (float.IsNaN(value) || value < (float)XpsMinDouble) 2300if (!float.IsNaN(a)) 2305if (!float.IsNaN(r)) 2310if (!float.IsNaN(g)) 2315if (!float.IsNaN(b))

Microsoft\CSharp\CSharpCodeGenerator.cs (1)

1519if (float.IsNaN(s))

Microsoft\VisualBasic\VBCodeGenerator.cs (1)

964if (float.IsNaN(s))

System\Formats\Cbor\Writer\CborWriter.Simple.netcoreapp.cs (1)

40return float.IsNaN(value) || BitConverter.SingleToInt32Bits((float)result) == BitConverter.SingleToInt32Bits(value);

System\Linq\MaxAsync.cs (2)

144while (float.IsNaN(value)) 221if (value is null || x > value || float.IsNaN((float)value))

System\Linq\MinAsync.cs (3)

138if (float.IsNaN(value)) 158else if (float.IsNaN(x)) 228if (value == null || x < value || float.IsNaN(x.GetValueOrDefault()))

System\Linq\Parallel\QueryOperators\Inlined\FloatMinMaxAggregationOperator.cs (4)

69if (current < best || float.IsNaN(current)) 80if (current > best || float.IsNaN(best)) 146if (elem < currentElement || float.IsNaN(elem)) 160if (elem > currentElement || float.IsNaN(currentElement))

System\Linq\Parallel\QueryOperators\Inlined\NullableFloatMinMaxAggregationOperator.cs (4)

70if (best == null || current < best || float.IsNaN(current.GetValueOrDefault())) 82if (best == null || current > best || float.IsNaN(best.GetValueOrDefault())) 150if (currentElement == null || elem < currentElement || float.IsNaN(elem.GetValueOrDefault())) 165if (currentElement == null || elem > currentElement || float.IsNaN(currentElement.GetValueOrDefault()))

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ArraySortHelper.cs (1)

1120(typeof(TKey) == typeof(float) && float.IsNaN((float)(object)keys[i])) ||

src\libraries\System.Private.CoreLib\src\System\Half.cs (1)

749uint realMask = float.IsNaN(value) ? 0u : ~0u;

src\libraries\System.Private.CoreLib\src\System\Math.cs (2)

1027if (!float.IsNaN(val1)) 1187if (!float.IsNaN(val1))

src\libraries\System.Private.CoreLib\src\System\MathF.cs (7)

143if (float.IsNaN(x)) 148if (float.IsNaN(y)) 155if (float.IsNaN(regularMod)) 221if (float.IsNaN(x)) 226if (float.IsNaN(y)) 263if ((ax > ay) || float.IsNaN(ax)) 295if ((ax < ay) || float.IsNaN(ax))

src\libraries\System.Private.CoreLib\src\System\Single.cs (15)

289if (IsNaN(m_value)) 291return IsNaN(value) ? 0 : -1; 294Debug.Assert(IsNaN(value)); 333return IsNaN(obj) && IsNaN(m_value); 980if (!IsNaN(y)) 1011if (!IsNaN(y)) 1171if ((ax > ay) || IsNaN(ay)) 1201if ((ax < ay) || IsNaN(ay)) 1429IsNaN(value) ? 0.0m : (decimal)value; 1451IsNaN(value) ? 0 : (ulong)value; 1553Debug.Assert(IsNaN(x) || IsNaN(y)); 1619else if (IsNaN(x)) 1664else if (IsNaN(x))

System\Xml\Serialization\XmlSerializationWriter.cs (1)

4317if (float.IsNaN((float)value))

System\Xml\XmlConvert.cs (1)

1707if (float.IsNaN(value))

System\Numerics\BigInteger.cs (2)

4380result = float.IsNaN(actualValue) ? Zero : (BigInteger)actualValue; 4497result = float.IsNaN(actualValue) ? Zero : (BigInteger)actualValue;

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.Float.cs (1)

155if (float.IsNaN(value))

System\Windows\Forms\Controls\RichTextBox\RichTextBox.cs (1)

1479if (!float.IsNaN(value))

System\Windows\Input\Manipulations\InertiaExpansionBehavior2D.cs (7)

266if (float.IsNaN(this.initialVelocityX) && float.IsNaN(this.initialVelocityY)) 280if (!float.IsNaN(this.desiredExpansionX) 281&& !float.IsNaN(this.desiredExpansionY) 290if (float.IsNaN(this.desiredDeceleration) 291&& (float.IsNaN(this.desiredExpansionX) || float.IsNaN(this.desiredExpansionY)))

System\Windows\Input\Manipulations\InertiaRotationBehavior2D.cs (3)

138if (float.IsNaN(this.initialVelocity)) 145if (float.IsNaN(this.desiredDeceleration) && float.IsNaN(this.desiredRotation))

System\Windows\Input\Manipulations\InertiaTranslationBehavior2D.cs (4)

161if (float.IsNaN(this.initialVelocityX) && float.IsNaN(this.initialVelocityY)) 168if (float.IsNaN(this.desiredDeceleration) && float.IsNaN(this.desiredDisplacement))

System\Windows\Input\Manipulations\ManipulationPivot2D.cs (3)

130return !float.IsNaN(this.x) && !float.IsNaN(this.y); 152if (!float.IsNaN(value) && (float.IsInfinity(value) || (value < 1.0F)))

System\Windows\Input\Manipulations\ManipulationSequence.cs (11)

System\Windows\Input\Manipulations\Validations.cs (3)

20return !float.IsNaN(value) && !float.IsInfinity(value); 44return float.IsNaN(value) || !float.IsInfinity(value); 68return !float.IsInfinity(value) && !float.IsNaN(value) && (value >= 0);

EqualityAsserts.cs (2)

467 if (float.IsNaN(tolerance) || float.IsNegativeInfinity(tolerance) || tolerance < 0.0) 948 if (float.IsNaN(tolerance) || float.IsNegativeInfinity(tolerance) || tolerance < 0.0)