/// <summary> /// Computes the error function for x. Adopted from http://www.johndcook.com/cpp_erf.html /// </summary> /// <param name="x"></param> /// <returns></returns> public static double Erf(double x) { // constants double a1 = 0.254829592; double a2 = -0.284496736; double a3 = 1.421413741; double a4 = -1.453152027; double a5 = 1.061405429; double p = 0.3275911; // Save the sign of x int sign = 1; if (x < 0) { sign = -1; } x = M.Abs(x); // A&S formula 7.1.26 double t = 1.0 / (1.0 + p * x); double y = 1.0 - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * M.Exp(-x * x); return(sign * y); }
public static float LinearInterpolate(Vector2 position, MapData[,] map, ScalarFieldType fieldType) { float x = position.X; float y = position.Y; float x1 = (int)MathFunctions.Clamp((float)Math.Ceiling(x), 0, map.GetLength(0) - 2); float y1 = (int)MathFunctions.Clamp((float)Math.Ceiling(y), 0, map.GetLength(1) - 2); float x2 = (int)MathFunctions.Clamp((float)Math.Floor(x), 0, map.GetLength(0) - 2); float y2 = (int)MathFunctions.Clamp((float)Math.Floor(y), 0, map.GetLength(1) - 2); if (Math.Abs(x1 - x2) < 0.5f) { x1 = x1 + 1; } if (Math.Abs(y1 - y2) < 0.5f) { y1 = y1 + 1; } float q11 = map[(int)x1, (int)y1].GetValue(fieldType); float q12 = map[(int)x1, (int)y2].GetValue(fieldType); float q21 = map[(int)x2, (int)y1].GetValue(fieldType); float q22 = map[(int)x2, (int)y2].GetValue(fieldType); return(MathFunctions.LinearCombination(x, y, x1, y1, x2, y2, q11, q12, q21, q22)); }
/// <summary> /// Resuelve el parametro de la clotoide dado los radios <c>r0</c> y <c>r1</c> Con una distancia <c>d</c> entre los /// puntos. /// </summary> private static double SolveParam(double d, double r0, double r1) { Func <double, double> f = (a) => { double fs0, fc0; ClothoUtils.Fresnel(a / (r0 * sqrtpi), out fs0, out fc0); double fs1, fc1; ClothoUtils.Fresnel(a / (r1 * sqrtpi), out fs1, out fc1); double fc10 = (fc1 - fc0); double fs10 = (fs1 - fs0); return(a * a * SysMath.PI * (fc10 * fc10 + fs10 * fs10) - d * d); }; int maxEval = 50; // 30 try { double min = 0; double max = SysMath.Min(SysMath.Abs(r0), SysMath.Abs(r1)) * ClothoUtils.MAX_L; double v = Solver.Solve(f, min, max, Solver.Type.BrentSolver, DEFAULT_ABSOLUTE_ACCURACY, maxEval); return(v); } catch (Exception e) { Debug.WriteLine(e); throw; } }
// // After rotating, the matrix needs to be translated. This function finds the area of image // which was previously centered and adjusts translations so that is again the center, post-rotation. // @param axis Matrix.MTRANS_X or Matrix.MTRANS_Y // @param trans the value of trans in that axis before the rotation // @param prevImageSize the width/height of the image before the rotation // @param imageSize width/height of the image after rotation // @param prevViewSize width/height of view before rotation // @param viewSize width/height of view after rotation // @param drawableSize width/height of drawable // private void TranslateMatrixAfterRotate(int axis, float trans, float prevImageSize, float imageSize, int prevViewSize, int viewSize, int drawableSize) { if (imageSize < viewSize) { // // The width/height of image is less than the view's width/height. Center it. // _m[axis] = (viewSize - (drawableSize * _m[Matrix.MscaleX])) * 0.5f; } else if (trans > 0) { // // The image is larger than the view, but was not before rotation. Center it. // _m[axis] = -((imageSize - viewSize) * 0.5f); } else { // // Find the area of the image which was previously centered in the view. Determine its distance // from the left/top side of the view as a fraction of the entire image's width/height. Use that percentage // to calculate the trans in the new view width/height. // var percentage = (Math.Abs(trans) + (0.5f * prevViewSize)) / prevImageSize; _m[axis] = -((percentage * imageSize) - (viewSize * 0.5f)); } }
/// <summary> /// Indicates whether the current object is equal to another object of the same type. /// </summary> /// <param name="other">An object to compare with this object.</param> /// <returns>true if the current object is equal to the <paramref name="other" /> parameter; otherwise, false.</returns> public bool Equals(Offset other) { return((NMath.Abs(I.X - other.I.X) < Tolerance) && (NMath.Abs(I.Y - other.I.Y) < Tolerance) && (NMath.Abs(J.X - other.J.X) < Tolerance) && (NMath.Abs(J.Y - other.J.Y) < Tolerance)); }
/// <summary> /// Multiplies the Color's Saturation, and Luminance or Brightness by the arguments; /// and optionally specifies the output Alpha. /// </summary> /// <param name="color">The color to transform.</param> /// <param name="colorTransformMode">Transform mode.</param> /// <param name="saturationTransform">The transformation multiplier.</param> /// <param name="brightnessTransform">The transformation multiplier.</param> /// <param name="outputAlpha">Can optionally specify the Alpha to directly /// set on the output. If null, then the input <paramref name="color"/> /// Alpha is used.</param> /// <returns>RGB Color.</returns> public static Color TransformSaturationAndValue( Color color, ColorTransformMode colorTransformMode, double saturationTransform, double brightnessTransform, byte?outputAlpha = null) { double[] hsl = colorTransformMode == ColorTransformMode.Hsl ? SimpleColorTransforms.RgbToHsl(color) : SimpleColorTransforms.RgbToHsb(color); if ((SystemMath.Abs(hsl[1]) < SimpleColorTransforms.tolerance) && (saturationTransform > 1D)) { hsl[1] = saturationTransform - 1D; } else { hsl[1] *= saturationTransform; } if ((SystemMath.Abs(hsl[2]) < SimpleColorTransforms.tolerance) && (brightnessTransform > 1D)) { hsl[2] = brightnessTransform - 1D; } else { hsl[2] *= brightnessTransform; } return(colorTransformMode == ColorTransformMode.Hsl ? SimpleColorTransforms.HslToRgb(hsl[0], hsl[1], hsl[2], outputAlpha ?? color.A) : SimpleColorTransforms.HsbToRgb(hsl[0], hsl[1], hsl[2], outputAlpha ?? color.A)); }
/// <summary> /// Computes the new motor velocity based on the current velocity, such that the velocity always moves towards /// the set point (if regulation is active), or the acceleration curve dictated by the <see cref="Acceleration" /> /// property. /// The magnitude of the returned speed will never be greater than <see cref="StepperMotor.MaximumSpeed" /> which in turn /// can never /// exceed <see cref="StepperMotor.MaximumPossibleSpeed" />. /// <see cref="StepperMotor.MaximumSpeed" />. /// </summary> /// <returns>The computed velocity, in steps per second.</returns> /// <remarks> /// A positive value indicates speed in the forward direction, while a negative value indicates speed in the reverse /// direction. /// 'forward' is defined as motion towards a higher position value; 'reverse' is defined as motion towards a lower /// position value. /// No attempt is made here to define the mechanical direction. A speed value that is within /// <see cref="StepperMotor.MotorStoppedThreshold" /> /// of zero is considered to mean that the motor should be stopped. /// </remarks> double ComputeAcceleratedVelocity() { var distanceToGo = ComputeDistanceToTarget(); var absoluteDistance = Math.Abs(distanceToGo); var direction = Math.Sign(distanceToGo); if (distanceToGo == 0) { return(0.0); // We're there. } if (!IsMoving) { return(Math.Sqrt(2.0 * Acceleration) * direction); // Accelerate away from stop. } // Compute the unconstrained target speed based on the deceleration curve or the regulation set point. var targetSpeed = regulating ? speedSetpoint : Math.Sqrt(2.0 * absoluteDistance * Acceleration) * direction; // The change in speed is a function of the absolute current speed and acceleration. var increment = Acceleration / Math.Abs(motorSpeed); var directionOfChange = Math.Sign(targetSpeed - motorSpeed); var newSpeed = motorSpeed + increment * directionOfChange; // The computed new speed must be constrained by both the MaximumSpeed and the acceleration curve. var clippedSpeed = newSpeed.ConstrainToLimits(-maximumSpeed, +maximumSpeed); return(clippedSpeed); }
public void CalculateStep(int numberOfSegments) { var set = new HashSet <OptimizationParameter> { new OptimizationStepParameter("ema-fast", 1, 100), new OptimizationStepParameter("ema-slow", -10, -10), new OptimizationStepParameter("ema-custom", -100, -1) }; _strategy.Initialize( new Target("Profit", new Maximization(), null), new List <Constraint>(), set, new StepBaseOptimizationStrategySettings { DefaultSegmentAmount = numberOfSegments }); foreach (var parameter in set) { var stepParameter = parameter as OptimizationStepParameter; Assert.NotNull(stepParameter); var actual = Math.Abs(stepParameter.MaxValue - stepParameter.MinValue) / numberOfSegments; Assert.AreEqual(actual, stepParameter.Step); Assert.AreEqual(actual / 10, stepParameter.MinStep); } }
/// <summary> /// Reads all of the formations and returns a list of objects with data. /// </summary> /// <param name="excel">The excel application.</param> /// <returns>List<DBLocation>.</returns> private static List <FormationMatcher> ReadFormations(ExcelFile excel) { List <FormationMatcher> locations = new List <FormationMatcher>(); List <string> areas = excel.RangeValuesBelowHeader("AreaChild"); List <string> names = excel.RangeValuesBelowHeader("Formation"); int numberOfRows = names.Count; List <string> latitudes = excel.RangeValuesBelowHeader("Latitude", includeNull: true, numberOfRows: numberOfRows); List <string> longitudes = excel.RangeValuesBelowHeader("Longitude", includeNull: true, numberOfRows: numberOfRows); List <string> otherNames = excel.RangeValuesBelowHeader("SubFormation", includeNull: true, numberOfRows: numberOfRows); for (int i = 0, length = names.Count; i < length; i++) { double longitude; if (!double.TryParse(longitudes[i], out longitude)) { longitude = 0; } double latitude; if (!double.TryParse(latitudes[i], out latitude)) { latitude = 0; } if (!(NMath.Abs(longitude) < 1) || !(NMath.Abs(latitude) < 1)) { continue; } FormationMatcher location = new FormationMatcher(areas[i], names[i], otherNames[i]); locations.Add(location); } return(locations); }
public static bool GetMeas(OSat sat, out double p1, out double p2, out double l1, out double l2, out double dp1) { dp1 = Common.DELTA_P1; p1 = p2 = l1 = l2 = 0d; if (sat is null || sat.SatData.Count <= 0) { return(false); } p1 = sat["P1"]; p2 = sat["P2"]; l1 = sat["L1"]; l2 = sat["L2"]; if (p1 == 0d) { p1 = sat["C1"]; dp1 = Common.DELTA_C1; } if (Math.Abs(l1) < 1e-3 || Math.Abs(l2) < 1e-3 || Math.Abs(p1) < 1e-3 || Math.Abs(p2) < 1e-3) { return(false); } return(true); }
public static Plane Normalize(Plane value) { const float FLT_EPSILON = 1.192092896e-07f; // smallest such that 1.0+FLT_EPSILON != 1.0 Plane result; float f = value.Normal.X * value.Normal.X + value.Normal.Y * value.Normal.Y + value.Normal.Z * value.Normal.Z; if (SM.Abs(f - 1.0f) < FLT_EPSILON) { result.Normal = value.Normal; result.D = value.D; return(result); // It already normalized, so we don't need to farther process. } float fInv = 1.0f / (float)SM.Sqrt(f); result.Normal.X = value.Normal.X * fInv; result.Normal.Y = value.Normal.Y * fInv; result.Normal.Z = value.Normal.Z * fInv; result.D = value.D * fInv; return(result); }
/// <summary> /// Returns the 3 'x' solutions to the equation x^3 + a2*x^2 + a1*x + a0 = 0. /// </summary> /// <param name="a0">Constant.</param> /// <param name="a1">Multiplier to x.</param> /// <param name="a2">Multiplier to x^2.</param> /// <param name="returnFirstRoot">if set to <c>true</c> [return first root].</param> /// <returns>System.Double[].</returns> private static double[] cubicCurveRootsNormalized(double a0, double a1, double a2, bool returnFirstRoot = false) { double Q = (3 * a1 - a2.Squared()) / 9d; double R = (9 * a2 * a1 - 27 * a0 - 2 * a2.Cubed()) / 54d; double D = Q.Cubed() + R.Squared(); double aCosRatio = R / Numbers.Sqrt(NMath.Abs(-Q.Cubed())); double x1; if ((returnFirstRoot && D.IsGreaterThanOrEqualTo(0)) || (aCosRatio.IsLessThan(-1) || aCosRatio.IsGreaterThan(1))) { double S = Numbers.CubeRoot(R + Numbers.Sqrt(D)); double T = Numbers.CubeRoot(R - Numbers.Sqrt(D)); x1 = (S + T) - (1 / 3d) * a2; return(new double[] { x1 }); } double theta = NMath.Acos(aCosRatio); x1 = 2 * Numbers.Sqrt((NMath.Abs(-Q))) * NMath.Cos(theta / 3d) - a2 / 3d; double x2 = 2 * Numbers.Sqrt(NMath.Abs(-Q)) * NMath.Cos((theta + 2 * Numbers.Pi) / 3d) - a2 / 3d; double x3 = 2 * Numbers.Sqrt(NMath.Abs(-Q)) * NMath.Cos((theta + 4 * Numbers.Pi) / 3d) - a2 / 3d; return(new double[] { x1, x2, x3 }); }
/// <summary> /// Moves the motor at a regulated speed, using acceleration whenever the speed changes. /// Once moving, the speed may be changed by calling this method again with the new value. /// To decelerate to a stop, call this method with a speed of 0. /// </summary> /// <param name="speed">The target speed.</param> /// <exception cref="System.ArgumentOutOfRangeException"> /// speed;speed must be in the range -MaximumPossibleSpeed to /// +MaximumPossibleSpeed /// </exception> public void MoveAtRegulatedSpeed(double speed) { var absoluteSpeed = Math.Abs(speed); if (absoluteSpeed > MaximumPossibleSpeed) { throw new ArgumentOutOfRangeException("speed", "speed must be in the range -MaximumPossibleSpeed to +MaximumPossibleSpeed"); } //if (maximumSpeed < absoluteSpeed) // maximumSpeed = absoluteSpeed; // Set the target position, effectively, infinitely far away so we will never stop. targetPosition = speed >= 0 ? int.MaxValue : int.MinValue; speedSetpoint = absoluteSpeed < MotorStoppedThreshold ? 0.0 : speed; var direction = (short)Math.Sign(targetPosition - currentPosition); lock (motorUpdateLock) { regulating = true; if (!IsMoving) { StartStepping(direction); } } }
public object GetCurrentValue(Brush defaultOriginValue, Brush defaultDestinationValue, AnimationClock animationClock) { if (!animationClock.CurrentProgress.HasValue) { return(Brushes.Transparent); } // use the standard values if From and To are not set // it is the value of the given property defaultOriginValue = From ?? defaultOriginValue; defaultDestinationValue = To ?? defaultDestinationValue; if (Math.Abs(animationClock.CurrentProgress.Value - 0) < 1e-5) { return(defaultOriginValue); } if (Math.Abs(animationClock.CurrentProgress.Value - 1) < 1e-5) { return(defaultDestinationValue); } return(new VisualBrush(new Border() { Width = 1, Height = 1, Background = defaultOriginValue, Child = new Border() { Background = defaultDestinationValue, Opacity = animationClock.CurrentProgress.Value } })); }
public override void SetOutputPowerAndPolarity(double duty) { bool polarity = duty >= 0.0; SetOutputPowerAndPolarity(Math.Abs(duty), polarity); base.SetOutputPowerAndPolarity(duty); }
private void setMouseCorner() { //var xSlope:double = (WIDTH / HEIGHT) * mouseY; //var ySlope:double = HEIGHT - (HEIGHT / WIDTH) * mouseX; double x = mouseX - (WIDTH - HEIGHT) * 0.5; double y = mouseY; double xSlope = y; double ySlope = HEIGHT - x; if (x > xSlope && y > ySlope) { mouseCorner = Room.RIGHT; } else if (x > xSlope && y < ySlope) { mouseCorner = Room.UP; } else if (x < xSlope && y > ySlope) { mouseCorner = Room.DOWN; } else if (x < xSlope && y < ySlope) { mouseCorner = Room.LEFT; } if (Math.Abs(mouseX - WIDTH * 0.5) < SCALE * 0.75 && Math.Abs(mouseY - HEIGHT * 0.5) < SCALE * 0.75) { mouseCorner = 0; } }
public Move ComputeMove(Position dest) { var move = new Move { Pos = new Position { X = dest.X - this.Speed.Vx, Y = dest.Y - this.Speed.Vy } }; // Acc var dist = this.Pos.Dist(move.Pos); if (Math.Abs(dist) <= 0.0001) { return(move); } //var expectedVx = Math.Abs(move.Pos.X - this.Pos.X) / (1 - this.Friction); //var expectedVy = Math.Abs(move.Pos.Y - this.Pos.Y) / (1 - this.Friction); //var accX = (int)Math.Round(expectedVx * dist * this.Mass); //var accY = (int)Math.Round(expectedVy * dist * this.Mass); //Program.ConsoleHelper.Debug($"accX={accX}|accY={accY}"); //move.Acc = Math.Min((accX + accY) / 2, 300); var acc = (int)Math.Round(this.Mass * dist); move.Acc = Math.Min(acc, 300); return(move); }
public static Quaternion Slerp(Quaternion p, Quaternion q, float time, bool useShortCut = false) { var cos = p.Dot(q); var angle = MathDotNet.Acos(cos); if (MathDotNet.Abs(angle) < Quaternion.EPSILONE) { return(p); } var sin = MathDotNet.Sin(angle); var inverseSin = 1f / sin; var coeff0 = MathDotNet.Sin((1f - time) * angle) * inverseSin; var coeff1 = MathDotNet.Sin(time * angle) * inverseSin; if (useShortCut == false || cos >= 0d) { return(p * coeff0 + q * coeff1); } coeff0 = -coeff0; Quaternion temp = p * coeff0 + q * coeff1; var factor = 1d / MathDotNet.Sqrt(temp.Normalized); return(temp * factor); }
public void DrawFade(View content, Canvas canvas, float openPercent) { if (!FadeEnabled) { return; } var alpha = (int)(FadeDegree * 255 * Math.Abs(1 - openPercent)); _fadePaint.Color = Color.Argb(alpha, 0, 0, 0); var left = 0; var right = 0; switch (Mode) { case MenuMode.Left: left = content.Left - BehindWidth; right = content.Left; break; case MenuMode.Right: left = content.Right; right = content.Right + BehindWidth; break; case MenuMode.LeftRight: left = content.Left - BehindWidth; right = content.Left; canvas.DrawRect(left, 0, right, Height, _fadePaint); left = content.Right; right = content.Right + BehindWidth; break; } canvas.DrawRect(left, 0, right, Height, _fadePaint); }
/// <summary> /// Find the expected exposure /// </summary> /// <param name="mtm"></param> /// <param name="pce"></param> /// <param name="expExp"></param> /// <param name="expExp2"></param> public static void Exposures(double mtm, double pce, out double expExp, out double expExp2) { //**** Step 2 - Find the Cumulative Normal Probability //**** CDF=1-NORMDIST(-MTM/PCE,0,1,TRUE) //**** Step 3 - Find the marginal Normal Probability //**** PDF=NORMDIST(-MTM/PCE,0,1,FALSE) //**** double cumulativeNormal = 1.0; double normalDensity = 0.0; if (Math.Abs(pce) > 1E-07) { normalDensity = NormalDistribution.Ndf(-mtm / pce); //use normal dist cumulativeNormal = 1.0 - new NormalDistribution().CumulativeDistribution(-mtm / pce); //use cum normal dist } //**** Step 4 - Find the expected exposure for the FX fwd //**** MTM*CDF+PCE*PDF //**** expExp = mtm * cumulativeNormal + pce * normalDensity; expExp2 = (Math.Pow(mtm, 2) + Math.Pow(pce, 2)) * cumulativeNormal + mtm * pce * normalDensity; }
public static List <Vector3Int> MakeLine(Vector3Int pos1, Vector3Int pos2) { List <Vector3Int> affected = new List <Vector3Int>(); bool notdrawn = true; int x1 = pos1.x; int y1 = pos1.x; int z1 = pos1.x; int x2 = pos2.x; int y2 = pos2.y; int z2 = pos2.z; int tipx = x1; int tipy = y1; int tipz = z1; int dx = Math.Abs(x2 - x1); int dy = Math.Abs(y2 - y1); int dz = Math.Abs(z2 - z1); if (dx + dy + dz == 0) { affected.Add(pos2 + new Vector3Int(tipx, tipy, tipz)); notdrawn = false; } if (Math.Max(Math.Max(dx, dy), dz) == dx && notdrawn) { for (int domstep = 0; domstep <= dx; domstep++) { tipx = x1 + domstep * (x2 - x1 > 0 ? 1 : -1); tipy = (int)Math.Round(y1 + domstep * (((double)dy) / ((double)dx)) * (y2 - y1 > 0 ? 1 : -1)); tipz = (int)Math.Round(z1 + domstep * (((double)dz) / ((double)dx)) * (z2 - z1 > 0 ? 1 : -1)); affected.Add(new Vector3Int(tipx, tipy, tipz)); } notdrawn = false; } if (Math.Max(Math.Max(dx, dy), dz) == dy && notdrawn) { for (int domstep = 0; domstep <= dx; domstep++) { tipx = x1 + domstep * (x2 - x1 > 0 ? 1 : -1); tipy = (int)Math.Round(y1 + domstep * ((double)dy) / ((double)dx) * (y2 - y1 > 0 ? 1 : -1)); tipz = (int)Math.Round(z1 + domstep * ((double)dz) / ((double)dx) * (z2 - z1 > 0 ? 1 : -1)); affected.Add(new Vector3Int(tipx, tipy, tipz)); } notdrawn = false; } if (Math.Max(Math.Max(dx, dy), dz) == dz && notdrawn) { for (int domstep = 0; domstep <= dz; domstep++) { tipz = z1 + domstep * (z2 - z1 > 0 ? 1 : -1); tipy = (int)Math.Round(y1 + domstep * ((double)dy) / ((double)dz) * (y2 - y1 > 0 ? 1 : -1)); tipx = (int)Math.Round(x1 + domstep * ((double)dx) / ((double)dz) * (x2 - x1 > 0 ? 1 : -1)); affected.Add(pos2 + new Vector3Int(tipx, tipy, tipz)); } } return(affected); }
public ClothoidArc2(double l0, Vector2d point0, Vector2d point1, double radius0, double radius1) { // Correccion sobre los radios. if (SysMath.Sign(radius1) != SysMath.Sign(radius0)) { if (double.IsInfinity(radius0)) { radius0 = SysMath.Sign(radius1) * double.PositiveInfinity; } else if (double.IsInfinity(radius1)) { radius1 = SysMath.Sign(radius0) * double.PositiveInfinity; } else { // No se permite cambio de signo en el radio. Funcionaria??? Contract.Assert(false); } } if (SysMath.Abs(radius0) > SysMath.Abs(radius1)) { // t positivas this.InvertY = radius1 < 0; } else { // t negativa this.InvertY = radius1 > 0; } // Diferencia de puntos en coordenadas reales. Vector2d v01 = point1.Sub(point0); this.A = SolveParam(v01.Length, radius0, radius1); // Desarrollo segun el radio en el punto (0) y (1). double l0_n = ClothoUtils.ClothoL(radius0, this.InvertY, this.A); double l1_n = ClothoUtils.ClothoL(radius1, this.InvertY, this.A); // Coordenadas en el punto (0) y (1) para una clotoide normalizada. Point2d p0_n = ClothoUtils.Clotho(l0_n, this.InvertY, this.A); Point2d p1_n = ClothoUtils.Clotho(l1_n, this.InvertY, this.A); Vector2d v01_n = p1_n.Sub(p0_n); // Rotacion de v01_n -> v01. double r = v01_n.AngleTo(v01); // Transformacion a aplicar. this.transform = Transform2.Translate(point1.X - p1_n.X, point1.Y - p1_n.Y) .Concat(Transform2.Rotate(p1_n.X, p1_n.Y, r)); this.l0 = l0_n; this.l1 = l1_n; this.SetTInterval(l0, l0 + (this.l1 - this.l0)); }
public static double SolveParam_2(double len, double r1, double r2) { Func <double, double> f = (a) => { double fs1, fc1; FresnelUtils.Fresnel(a / (r1 * sqrtpi), out fs1, out fc1); double fs2, fc2; FresnelUtils.Fresnel(a / (r2 * sqrtpi), out fs2, out fc2); double fc21 = (fc2 - fc1); double fs21 = (fs2 - fs1); return(a * a * SysMath.PI * (fc21 * fc21 + fs21 * fs21) - len * len); }; int maxEval = 50; // 30 try { double min = 0; double max = SysMath.Min(SysMath.Abs(r1), SysMath.Abs(r2)) * MAX_L; return(Solver.Solve(f, min, max, Solver.Type.Brent, Solver.DEFAULT_ABSOLUTE_ACCURACY, maxEval)); } catch (Exception e) { Debug.WriteLine(e); throw; } }
// d = b^2 - a * c computed accurately enough by a tricky scheme. // Ported from @hkrish's polysolve.c private static Real GetDiscriminant(Real a, Real b, Real c) { Func <Real, Real[]> split = (v) => { Real x = v * 134217729; Real y = v - x; Real hi = y + x; // Don't optimize y away! Real lo = v - hi; return(new[] { hi, lo }); }; Real D = b * b - a * c; Real E = b * b + a * c; if (Math.Abs(D) * 3 < E) { Real[] ad = split(a); Real[] bd = split(b); Real[] cd = split(c); Real p = b * b; Real dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1]; Real q = a * c; Real dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0]) + ad[1] * cd[1]; D = (p - q) + (dp - dq); // Don’t omit parentheses! } return(D); }
void UpdateVisibleRegion(LatLng pos) { var map = NativeMap; if (map == null) { return; } var projection = map.Projection; var width = Control.Width; var height = Control.Height; var ul = projection.FromScreenLocation(new global::Android.Graphics.Point(0, 0)); var ur = projection.FromScreenLocation(new global::Android.Graphics.Point(width, 0)); var ll = projection.FromScreenLocation(new global::Android.Graphics.Point(0, height)); var lr = projection.FromScreenLocation(new global::Android.Graphics.Point(width, height)); var dlat = Math.Max(Math.Abs(ul.Latitude - lr.Latitude), Math.Abs(ur.Latitude - ll.Latitude)); var dlong = Math.Max(Math.Abs(ul.Longitude - lr.Longitude), Math.Abs(ur.Longitude - ll.Longitude)); ((Map)Element).VisibleRegion = new MapSpan( new Position( pos.Latitude, pos.Longitude ), dlat, dlong ); }
///<summary> ///</summary> ///<param name="optionType"></param> ///<param name="price"></param> ///<param name="strike"></param> ///<returns></returns> ///<exception cref="ArgumentOutOfRangeException"></exception> public static double ExercisePayoff(Type optionType, double price, double strike) { switch (optionType) { case Type.Call: { return(Math.Max(price - strike, 0.0)); } case Type.Put: { return(Math.Max(strike - price, 0.0)); } case Type.Straddle: { return(Math.Abs(strike - price)); } default: { throw new ArgumentOutOfRangeException(nameof(optionType), optionType, "TODO: Unknown option type"); } } }
internal static bool LineSegmentIntersection(Vector2Double p1, Vector2Double p2, Vector2Double p3, Vector2Double p4, ref Vector2Double result) { double num1 = p2.x - p1.x; double num2 = p2.y - p1.y; double num3 = p4.x - p3.x; double num4 = p4.y - p3.y; double num5 = (num1 * num4 - num2 * num3); if (Math.Abs(num5) < Epsilon) { return(false); } double num6 = p3.x - p1.x; double num7 = p3.y - p1.y; double num8 = (num6 * num4 - num7 * num3) / num5; if (num8 < 0.0d || num8 > 1.0d) { return(false); } double num9 = (num6 * num2 - num7 * num1) / num5; if (num9 < 0.0d || num9 > 1.0d) { return(false); } result = new Vector2Double(p1.x + num8 * num1, p1.y + num8 * num2); return(true); }
public Main() { InitializeBot(); InitializeComponent(); Translate(); InitializeLogging(); if (nManagerSetting.CurrentSetting.ActivateAlwaysOnTopFeature) { TopMost = true; } InitializeUI(); Logging.Status = "Startup Complete"; using (Graphics g = CreateGraphics()) { if (Math.Abs(g.DpiX - 96F) > 0.1) { Logging.Write("There is a problem with your Windows Font Size configuration."); Logging.Write("Please set it to 100% size or you may have problems reading TheNoobBot's forms. hint: http://www.wikihow.com/Change-Font-Size-on-a-Computer"); } } if (nManagerSetting.AutoStartProduct && !string.IsNullOrEmpty(nManagerSetting.AutoStartProductName) && !string.IsNullOrEmpty(nManagerSetting.AutoStartProfileName)) { if (!string.IsNullOrEmpty(nManagerSetting.CurrentSetting.LastProductLoaded) && nManagerSetting.AutoStartProductName.ToLower() == nManagerSetting.CurrentSetting.LastProductLoaded.Split('-')[0].Trim().ToLower()) { Products.ProductRemoteStart(new[] { nManagerSetting.AutoStartProfileName }); } } else if (nManagerSetting.AutoStartProduct) { Products.ProductRemoteStart(new string[0]); } }
public ClothoidArc2(double l0, Vec2d point0, Vec2d point1, double radius0, double radius1, double a) { // Correccion sobre los radios. if (SysMath.Sign(radius1) != SysMath.Sign(radius0)) { if (double.IsInfinity(radius0)) { radius0 = SysMath.Sign(radius1) * double.PositiveInfinity; } else if (double.IsInfinity(radius1)) { radius1 = SysMath.Sign(radius0) * double.PositiveInfinity; } else { // Se deja tal cual. //// Se toma el radio inicio como infinito. ////radius0 = SysMath.Sign(radius1) * double.PositiveInfinity; } } if (SysMath.Abs(radius0) > SysMath.Abs(radius1)) { // t positivas this.invertY = radius1 < 0; } else { // t negativa this.invertY = radius1 > 0; } // Diferencia de puntos en coordenadas reales. Vec2d v01 = point1.Sub(point0); this.a = a; // Desarrollo segun el radio en el punto (0) y (1). double l0_n = ClothoUtils.ClothoL(radius0, this.invertY, this.a); double l1_n = ClothoUtils.ClothoL(radius1, this.invertY, this.a); // Coordenadas en el punto (0) y (1) para una clotoide normalizada. Vec2d p0_n = ClothoUtils.Clotho(l0_n, this.invertY, this.a); Vec2d p1_n = ClothoUtils.Clotho(l1_n, this.invertY, this.a); Vec2d v01_n = p1_n.Sub(p0_n); // Rotacion de v01_n -> v01. double r = vecMath.Angle(v01_n, v01); // Transformacion a aplicar. this.transform = Transform2.Translate(point1.X - p1_n.X, point1.Y - p1_n.Y) .Mult(Transform2.Rotate(p1_n.X, p1_n.Y, r)); this.l0 = l0_n; this.l1 = l1_n; this.SetTInterval(l0, l0 + (this.l1 - this.l0)); }
/// <summary> /// Rotates the images with an optimized method when the angle is 90, 180 or 270 degrees. /// </summary> /// <param name="source">The source image.</param> /// <param name="destination">The destination image.</param> /// <param name="configuration">The configuration.</param> /// <returns> /// The <see cref="bool" /> /// </returns> private bool OptimizedApply(ImageFrame <TPixel> source, ImageFrame <TPixel> destination, Configuration configuration) { // Wrap the degrees to keep within 0-360 so we can apply optimizations when possible. float degrees = WrapDegrees(this.Degrees); if (MathF.Abs(degrees) < Constants.Epsilon) { // The destination will be blank here so copy all the pixel data over source.GetPixelSpan().CopyTo(destination.GetPixelSpan()); return(true); } if (MathF.Abs(degrees - 90) < Constants.Epsilon) { this.Rotate90(source, destination, configuration); return(true); } if (MathF.Abs(degrees - 180) < Constants.Epsilon) { this.Rotate180(source, destination, configuration); return(true); } if (MathF.Abs(degrees - 270) < Constants.Epsilon) { this.Rotate270(source, destination, configuration); return(true); } return(false); }