private static bool ProportionalLines(float[][] matrix, float[] vector, int i, int j) { float firstQuotient = matrix[i][0] / matrix[j][0]; float secondQuotient = matrix[i][1] / matrix[j][1]; float thirdQuotient = vector[i] / vector[j]; if (firstQuotient.ApproximatelyEquals(secondQuotient, _approximation) && firstQuotient.ApproximatelyEquals(thirdQuotient, _approximation)) { return(true); } if (float.IsNaN(firstQuotient) && secondQuotient.ApproximatelyEquals(thirdQuotient, _approximation)) { return(true); } if (float.IsNaN(secondQuotient) && firstQuotient.ApproximatelyEquals(thirdQuotient, _approximation)) { return(true); } if (float.IsNaN(thirdQuotient) && firstQuotient.ApproximatelyEquals(secondQuotient, _approximation)) { return(true); } return(false); }
private void AdjustHeightIfNeeded() { if (!_preventExpandingHeight) { return; } if (_contentHeight.ApproximatelyEquals(position.height)) { return; } Rect positionToAdjust = position; positionToAdjust.height = Math.Min(_contentHeight, DropdownStyle.MaxWindowHeight); minSize = new Vector2(minSize.x, positionToAdjust.height); maxSize = new Vector2(maxSize.x, positionToAdjust.height); float screenHeight = Screen.currentResolution.height - 40f; if (positionToAdjust.yMax >= screenHeight) { positionToAdjust.y -= positionToAdjust.yMax - screenHeight; } position = positionToAdjust; }
public bool Equals(Vector other) { return(X.ApproximatelyEquals(other.X) && Y.ApproximatelyEquals(other.Y) && Z.ApproximatelyEquals(other.Z) && W.ApproximatelyEquals(other.W)); }
public void ToggleGlow(bool enable) { if (enable == originalGlowRadius.ApproximatelyEquals(Props.glowRadius)) { return; } Props.glowRadius = enable ? originalGlowRadius : 0f; // reset cache in parent class RemoteTechController.Instance.CompGlowerGlowOnField.SetValue(this, !(bool)RemoteTechController.Instance.CompGlowerShouldBeLitProperty.GetValue(this, null)); UpdateLit(parent.Map); }
public void Intersect(Point origin, Vector direction, float t0, float t1) { var cone = new Cone(); direction = Vector.Normalize(direction); var ray = new Ray(origin, direction); var intersections = cone.Intersect(ray); Assert.Equal(2, intersections.Count); Assert.True(t0.ApproximatelyEquals(intersections[0].Time)); Assert.True(t1.ApproximatelyEquals(intersections[1].Time)); }
public void ApproximatelyEquals_ShouldReturnExpectedResult( float lhs, float rhs, bool expected ) { // arrange // act var actual = lhs.ApproximatelyEquals(rhs); // assert actual.Should().Be(expected, $"{lhs} should {(expected ? "" : "not ")} equal {rhs}"); }
public Color RefractedColor(IntersectionInfo info, int remaining) { if (remaining < 1) { return(Color.Black); } float materialTransparency = info.Intersection.Shape.Material.Transparency; if (materialTransparency.ApproximatelyEquals(0)) { return(Color.Black); } // Find the ratio of the first index of refraction to the second float ratio = info.RefractiveIndex1 / info.RefractiveIndex2; // Theta_i is the angle of the incoming ray // Cos(Theta_i) is the same as the dot product of the two vectors float cosineI = Vector.Dot(info.EyeVector, info.Normal); // Theta_t is the angle of the refracted ray // Find Sin(Theta_t)^2 float sin2T = (ratio * ratio) * (1 - (cosineI * cosineI)); if (sin2T > 1) { // Total internal reflection return(Color.Black); } float cosineT = MathF.Sqrt(1 - sin2T); // Compute direction of the refracted ray var direction = info.Normal * (ratio * cosineI - cosineT) - info.EyeVector * ratio; var refractedRay = new Ray(info.UnderPoint, direction); return(ColorAt(refractedRay, remaining - 1) * materialTransparency); }
public bool Equals(Distance other) { return(AsMeters .ApproximatelyEquals(other.AsMeters)); }
public static bool ApproximatelyGreaterThan(this float thisFloat, float otherFloat, float differenceCap) { return((thisFloat > otherFloat) || thisFloat.ApproximatelyEquals(otherFloat, differenceCap)); }
public bool Equals(Speed other) { return(AsMetersPerSecond .ApproximatelyEquals(other.AsKilometersPerHour)); }
/// <summary>Determines if the number are not equal with a certain tolerance.</summary> /// <param name="firstNum">First number.</param> /// <param name="secondNum">Second number.</param> /// <param name="tolerance">Tolerance by which to determine if the numbers are equal. Default is 0.01f.</param> /// <returns>Whether the numbers are not equal with tolerance.</returns> /// <example><code> /// if (_optimalWidth.DoesNotEqualApproximately(position.width)) /// this.Resize(_optimalWidth); /// </code></example> [PublicAPI] public static bool DoesNotEqualApproximately(this float firstNum, float secondNum, float tolerance = 0.01f) => !firstNum.ApproximatelyEquals(secondNum, tolerance);
public bool Equals(Color other) { return(R.ApproximatelyEquals(other.R) && G.ApproximatelyEquals(other.G) && B.ApproximatelyEquals(other.B)); }