private static int Math_Exp(ILuaState lua) { lua.PushNumber(Math.Exp(lua.L_CheckNumber(1))); return(1); }
/// <summary> /// Force a root found by a non-bracketing solver to lie on a specified side, /// as if the solver were a bracketing one. /// </summary> /// <param name="maxEval"> maximal number of new evaluations of the function /// (evaluations already done for finding the root should have already been subtracted /// from this number) </param> /// <param name="f"> function to solve </param> /// <param name="bracketing"> bracketing solver to use for shifting the root </param> /// <param name="baseRoot"> original root found by a previous non-bracketing solver </param> /// <param name="min"> minimal bound of the search interval </param> /// <param name="max"> maximal bound of the search interval </param> /// <param name="allowedSolution"> the kind of solutions that the root-finding algorithm may /// accept as solutions. </param> /// <returns> a root approximation, on the specified side of the exact root </returns> /// <exception cref="NoBracketingException"> if the function has the same sign at the /// endpoints. </exception> //JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET: //ORIGINAL LINE: public static double forceSide(final int maxEval, final org.apache.commons.math3.analysis.UnivariateFunction f, final BracketedUnivariateSolver<org.apache.commons.math3.analysis.UnivariateFunction> bracketing, final double baseRoot, final double min, final double max, final AllowedSolution allowedSolution) throws org.apache.commons.math3.exception.NoBracketingException public static double ForceSide(int maxEval, UnivariateFunction f, BracketedUnivariateSolver <UnivariateFunction> bracketing, double baseRoot, double min, double max, AllowedSolution allowedSolution) { if (allowedSolution == AllowedSolution.ANY_SIDE) { // no further bracketing required return(baseRoot); } // find a very small interval bracketing the root //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final double step = org.apache.commons.math3.util.FastMath.max(bracketing.getAbsoluteAccuracy(), org.apache.commons.math3.util.FastMath.abs(baseRoot * bracketing.getRelativeAccuracy())); double step = FastMath.Max(bracketing.GetAbsoluteAccuracy(), FastMath.Abs(baseRoot * bracketing.GetRelativeAccuracy())); double xLo = FastMath.Max(min, baseRoot - step); double fLo = f.Value(xLo); double xHi = FastMath.Min(max, baseRoot + step); double fHi = f.Value(xHi); int remainingEval = maxEval - 2; while (remainingEval > 0) { if ((fLo >= 0 && fHi <= 0) || (fLo <= 0 && fHi >= 0)) { // compute the root on the selected side return(bracketing.Solve(remainingEval, f, xLo, xHi, baseRoot, allowedSolution)); } // try increasing the interval bool changeLo = false; bool changeHi = false; if (fLo < fHi) { // increasing function if (fLo >= 0) { changeLo = true; } else { changeHi = true; } } else if (fLo > fHi) { // decreasing function if (fLo <= 0) { changeLo = true; } else { changeHi = true; } } else { // unknown variation changeLo = true; changeHi = true; } // update the lower bound if (changeLo) { xLo = FastMath.Max(min, xLo - step); fLo = f.Value(xLo); remainingEval--; } // update the higher bound if (changeHi) { xHi = FastMath.Min(max, xHi + step); fHi = f.Value(xHi); remainingEval--; } } throw new NoBracketingException(LocalizedFormats.FAILED_BRACKETING, xLo, xHi, fLo, fHi, maxEval - remainingEval, maxEval, baseRoot, min, max); }
/// <summary> /// This method attempts to find two values a and b satisfying <ul> /// <li> {@code lowerBound <= a < initial < b <= upperBound} </li> /// <li> {@code f(a) * f(b) <= 0} </li> /// </ul> /// If {@code f} is continuous on {@code [a,b]}, this means that {@code a} /// and {@code b} bracket a root of {@code f}. /// <para> /// The algorithm checks the sign of \( f(l_k) \) and \( f(u_k) \) for increasing /// values of k, where \( l_k = max(lower, initial - \delta_k) \), /// \( u_k = min(upper, initial + \delta_k) \), using recurrence /// \( \delta_{k+1} = r \delta_k + q, \delta_0 = 0\) and starting search with \( k=1 \). /// The algorithm stops when one of the following happens: <ul> /// <li> at least one positive and one negative value have been found -- success!</li> /// <li> both endpoints have reached their respective limits -- NoBracketingException </li> /// <li> {@code maximumIterations} iterations elapse -- NoBracketingException </li></ul> /// </para> /// <para> /// If different signs are found at first iteration ({@code k=1}), then the returned /// interval will be \( [a, b] = [l_1, u_1] \). If different signs are found at a later /// iteration {@code k>1}, then the returned interval will be either /// \( [a, b] = [l_{k+1}, l_{k}] \) or \( [a, b] = [u_{k}, u_{k+1}] \). A root solver called /// with these parameters will therefore start with the smallest bracketing interval known /// at this step. /// </para> /// <para> /// Interval expansion rate is tuned by changing the recurrence parameters {@code r} and /// {@code q}. When the multiplicative factor {@code r} is set to 1, the sequence is a /// simple arithmetic sequence with linear increase. When the multiplicative factor {@code r} /// is larger than 1, the sequence has an asymptotically exponential rate. Note than the /// additive parameter {@code q} should never be set to zero, otherwise the interval would /// degenerate to the single initial point for all values of {@code k}. /// </para> /// <para> /// As a rule of thumb, when the location of the root is expected to be approximately known /// within some error margin, {@code r} should be set to 1 and {@code q} should be set to the /// order of magnitude of the error margin. When the location of the root is really a wild guess, /// then {@code r} should be set to a value larger than 1 (typically 2 to double the interval /// length at each iteration) and {@code q} should be set according to half the initial /// search interval length. /// </para> /// <para> /// As an example, if we consider the trivial function {@code f(x) = 1 - x} and use /// {@code initial = 4}, {@code r = 1}, {@code q = 2}, the algorithm will compute /// {@code f(4-2) = f(2) = -1} and {@code f(4+2) = f(6) = -5} for {@code k = 1}, then /// {@code f(4-4) = f(0) = +1} and {@code f(4+4) = f(8) = -7} for {@code k = 2}. Then it will /// return the interval {@code [0, 2]} as the smallest one known to be bracketing the root. /// As shown by this example, the initial value (here {@code 4}) may lie outside of the returned /// bracketing interval. /// </para> </summary> /// <param name="function"> function to check </param> /// <param name="initial"> Initial midpoint of interval being expanded to /// bracket a root. </param> /// <param name="lowerBound"> Lower bound (a is never lower than this value). </param> /// <param name="upperBound"> Upper bound (b never is greater than this /// value). </param> /// <param name="q"> additive offset used to compute bounds sequence (must be strictly positive) </param> /// <param name="r"> multiplicative factor used to compute bounds sequence </param> /// <param name="maximumIterations"> Maximum number of iterations to perform </param> /// <returns> a two element array holding the bracketing values. </returns> /// <exception cref="NoBracketingException"> if function cannot be bracketed in the search interval </exception> //JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET: //ORIGINAL LINE: public static double[] bracket(final org.apache.commons.math3.analysis.UnivariateFunction function, final double initial, final double lowerBound, final double upperBound, final double q, final double r, final int maximumIterations) throws org.apache.commons.math3.exception.NoBracketingException public static double[] Bracket(UnivariateFunction function, double initial, double lowerBound, double upperBound, double q, double r, int maximumIterations) { if (function == null) { throw new NullArgumentException(LocalizedFormats.FUNCTION); } if (q <= 0) { throw new NotStrictlyPositiveException(q); } if (maximumIterations <= 0) { throw new NotStrictlyPositiveException(LocalizedFormats.INVALID_MAX_ITERATIONS, maximumIterations); } VerifySequence(lowerBound, initial, upperBound); // initialize the recurrence double a = initial; double b = initial; double fa = double.NaN; double fb = double.NaN; double delta = 0; for (int numIterations = 0; (numIterations < maximumIterations) && (a > lowerBound || b < upperBound); ++numIterations) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final double previousA = a; double previousA = a; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final double previousFa = fa; double previousFa = fa; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final double previousB = b; double previousB = b; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final double previousFb = fb; double previousFb = fb; delta = r * delta + q; a = FastMath.Max(initial - delta, lowerBound); b = FastMath.Min(initial + delta, upperBound); fa = function.Value(a); fb = function.Value(b); if (numIterations == 0) { // at first iteration, we don't have a previous interval // we simply compare both sides of the initial interval if (fa * fb <= 0) { // the first interval already brackets a root return(new double[] { a, b }); } } else { // we have a previous interval with constant sign and expand it, // we expect sign changes to occur at boundaries if (fa * previousFa <= 0) { // sign change detected at near lower bound return(new double[] { a, previousA }); } else if (fb * previousFb <= 0) { // sign change detected at near upper bound return(new double[] { previousB, b }); } } } // no bracketing found throw new NoBracketingException(a, b, fa, fb); }
public override bool OnTouchEvent(MotionEvent e) { if (_coordinatorListener == null) { return(base.OnTouchEvent(e)); } int x = (int)e.RawX; int y = (int)e.RawY; switch (e.Action) { case MotionEventActions.Down: _downPositionY = e.RawY; break; case MotionEventActions.Move: int deltaY = (int)(_downPositionY - y); if (IsScrollTop(e) ? _coordinatorListener.OnCoordinateScroll(x, y, 0, deltaY + Math.Abs(_dragDistanceY), true) : _coordinatorListener.OnCoordinateScroll(x, y, 0, deltaY, IsScrollTop(e))) { return(true); } break; case MotionEventActions.Cancel: case MotionEventActions.Up: _scrollTop = false; if (_coordinatorListener.IsBeingDragged) { _coordinatorListener.OnSwitch(); return(true); } break; } return(base.OnTouchEvent(e)); }
public void GoldenRatio() { Assert.Equal(1.61803398875, NMath.Round(Numbers.GoldenRatio(), 11)); }
public void CreateRegular(int p, double q) { Segments.Clear(); List <Vector3D> points = new List <Vector3D>(); Geometry g = Geometry2D.GetGeometry(p, q); double circumRadius = Geometry2D.GetNormalizedCircumRadius(p, q); double angle = 0; for (int i = 0; i < p; i++) { Vector3D point = new Vector3D(); point.X = (circumRadius * Math.Cos(angle)); point.Y = (circumRadius * Math.Sin(angle)); points.Add(point); angle += Utils.DegreesToRadians(360.0 / p); } // Turn this into segments. for (int i = 0; i < points.Count; i++) { int idx1 = i; int idx2 = i == points.Count - 1 ? 0 : i + 1; Segment newSegment = new Segment(); newSegment.P1 = points[idx1]; newSegment.P2 = points[idx2]; if (g != Geometry.Euclidean) { newSegment.Type = SegmentType.Arc; if (2 == p) { // Our magic formula below breaks down for digons. double factor = Math.Tan(Math.PI / 6); newSegment.Center = newSegment.P1.X > 0 ? new Vector3D(0, -circumRadius, 0) * factor : new Vector3D(0, circumRadius, 0) * factor; } else { // Our segments are arcs in Non-Euclidean geometries. // Magically, the same formula turned out to work for both. // (Maybe this is because the Poincare Disc model of the // hyperbolic plane is stereographic projection as well). double piq = q == -1 ? 0 : Math.PI / q; // Handle q infinite. double t1 = Math.PI / p; double t2 = Math.PI / 2 - piq - t1; double factor = (Math.Tan(t1) / Math.Tan(t2) + 1) / 2; newSegment.Center = (newSegment.P1 + newSegment.P2) * factor; } newSegment.Clockwise = Geometry.Spherical == g ? false : true; } // XXX - Make this configurable? // This is the color of cell boundary lines. //newSegment.m_color = CColor( 1, 1, 0, 1 ); Segments.Add(newSegment); } }
public virtual string[][] GetSegments() { IList <string[]> segments = new List <string[]>(); int segmentLimit = factory.GetTarget().GetSerializedATNSegmentLimit(); for (int i = 0; i < serialized.Count; i += segmentLimit) { IList <string> currentSegment = new System.ArraySegment <string>(serialized.ToArray(), i, Math.Min(i + segmentLimit, serialized.Count) - i); segments.Add(currentSegment.ToArray()); } return(segments.ToArray()); }
public static double Smoothed(double frac, double max) { return((max / 2.0) * (-Math.Cos(Math.PI * frac) + 1)); }
/// <summary> /// Find a real root in the given interval. /// </summary> /// <param name="min"> Lower bound for the interval. </param> /// <param name="max"> Upper bound for the interval. </param> /// <param name="fMin"> function value at the lower bound. </param> /// <param name="fMax"> function value at the upper bound. </param> /// <returns> the point at which the function value is zero. </returns> /// <exception cref="TooManyEvaluationsException"> if the allowed number of calls to /// the function to be solved has been exhausted. </exception> private double Solve(double min, double max, double fMin, double fMax) { double relativeAccuracy = this.RelativeAccuracy; double absoluteAccuracy = this.AbsoluteAccuracy; double functionValueAccuracy = this.FunctionValueAccuracy; // [x0, x2] is the bracketing interval in each iteration // x1 is the last approximation and an interpolation point in (x0, x2) // x is the new root approximation and new x1 for next round // d01, d12, d012 are divided differences double x0 = min; double y0 = fMin; double x2 = max; double y2 = fMax; double x1 = 0.5 * (x0 + x2); double y1 = this.ComputeObjectiveValue(x1); double oldx = double.PositiveInfinity; while (true) { // Muller's method employs quadratic interpolation through // x0, x1, x2 and x is the zero of the interpolating parabola. // Due to bracketing condition, this parabola must have two // real roots and we choose one in [x0, x2] to be x. double d01 = (y1 - y0) / (x1 - x0); double d12 = (y2 - y1) / (x2 - x1); double d012 = (d12 - d01) / (x2 - x0); double c1 = d01 + (x1 - x0) * d012; double delta = c1 * c1 - 4 * y1 * d012; double xplus = x1 + (-2.0 * y1) / (c1 + FastMath.Sqrt(delta)); double xminus = x1 + (-2.0 * y1) / (c1 - FastMath.Sqrt(delta)); // xplus and xminus are two roots of parabola and at least // one of them should lie in (x0, x2) double x = this.IsSequence(x0, xplus, x2) ? xplus : xminus; double y = this.ComputeObjectiveValue(x); // check for convergence double tolerance = FastMath.Max(relativeAccuracy * FastMath.Abs(x), absoluteAccuracy); if (FastMath.Abs(x - oldx) <= tolerance || FastMath.Abs(y) <= functionValueAccuracy) { return(x); } // Bisect if convergence is too slow. Bisection would waste // our calculation of x, hopefully it won't happen often. // the real number equality test x == x1 is intentional and // completes the proximity tests above it bool bisect = (x <x1 && (x1 - x0)> 0.95 * (x2 - x0)) || (x > x1 && (x2 - x1) > 0.95 * (x2 - x0)) || (x == x1); // prepare the new bracketing interval for next iteration if (!bisect) { x0 = x < x1 ? x0 : x1; y0 = x < x1 ? y0 : y1; x2 = x > x1 ? x2 : x1; y2 = x > x1 ? y2 : y1; x1 = x; y1 = y; oldx = x; } else { double xm = 0.5 * (x0 + x2); double ym = this.ComputeObjectiveValue(xm); if (MyUtils.Signum(y0) + MyUtils.Signum(ym) == 0.0) { x2 = xm; y2 = ym; } else { x0 = xm; y0 = ym; } x1 = 0.5 * (x0 + x2); y1 = this.ComputeObjectiveValue(x1); oldx = double.PositiveInfinity; } } }
private static Rectangle GetBoundingRectangle(Vector2 tl, Vector2 tr, Vector2 bl, Vector2 br) { // Find the minimum and maximum "corners" based on the given vectors float minX = MathF.Min(tl.X, MathF.Min(tr.X, MathF.Min(bl.X, br.X))); float maxX = MathF.Max(tl.X, MathF.Max(tr.X, MathF.Max(bl.X, br.X))); float minY = MathF.Min(tl.Y, MathF.Min(tr.Y, MathF.Min(bl.Y, br.Y))); float maxY = MathF.Max(tl.Y, MathF.Max(tr.Y, MathF.Max(bl.Y, br.Y))); float sizeX = maxX - minX + .5F; float sizeY = maxY - minY + .5F; return(new Rectangle((int)(MathF.Ceiling(minX) - .5F), (int)(MathF.Ceiling(minY) - .5F), (int)MathF.Floor(sizeX), (int)MathF.Floor(sizeY))); }