Finite | Mostly fluent configured Finite State Machine

You need to specify what's in playlist_names passed as choices = , quoted from ?selectinput:

List of values to select from. If elements of the list are named, then that name — rather than the value — is displayed to the user. It's also possible to group related inputs by providing a named list whose elements are (either named or unnamed) lists, vectors, or factors. In this case, the outermost names will be used as the group labels (leveraging the HTML tag) for the elements in the respective sublist. See the example section for a small demo of this feature.

Working example:

In roundhalfup, replace int(...) with math.floor(...):

You can split the dataset for each combination of group and use map to apply the plot function to each group.

Since you explicitly asked for a one-liner, here it is:

Let's start with a definition that pins down exactly which fraction we're looking for in any particular case:

Definition. Say that a fraction a/b is simpler than another fraction c/d (with both fractions written in lowest terms, with positive denominators) if b <= d, abs(a) <= abs(c), and at least one of those two inequalities is strict.

So for example 5/7 is simpler than 6/7, and 5/7 is simpler than 5/8, but neither 2/5 nor 3/4 is simpler than the other. (We don't have a total ordering here.)

Then with this definition, there's a not-immediately-obvious theorem, that guarantees that the fraction we're looking for always exists:

Theorem. Given a subinterval J of the real numbers that contains at least one fraction, J contains a unique simplest fraction. In other words, there's a unique fraction f such that

• f is in J and,
• for any other fraction g in J, f is simpler than g.

In particular, the simplest fraction in an interval will always have smallest possible denominator, as required in the question. The "contains at least one fraction" condition in the theorem is there to exclude degenerate cases like the closed interval [√2, √2], which doesn't contain any fractions at all.

Our job is to write a function that takes a finite floating-point input x and returns the simplest fraction n/d for which x is the closest float to n/d, in the target floating-point format. Assuming a reasonably sane floating-point format and rounding mode, the set of real numbers that round to x will form a nonempty subinterval of the real line, with rational endpoints. So our problem breaks naturally into two subproblems:

• Problem 1. Given a float x in the target floating-point format, describe the interval of all values that round to x under the rules for that floating-point format. This involves both identifying the endpoints of that interval and establishing whether the interval is open, closed, or half-open.

• Problem 2. Given a nonempty subinterval J of the real line with rational endpoints, compute the simplest fraction in that subinterval.

The second problem is more interesting and less dependent on platform and language details; let's tackle that one first.

Assuming an IEEE 754 floating-point format and the default round-ties-to-even rounding mode, the interval rounding to a given float will be either open or closed; with other rounding modes or formats, it could potentially be half open (open at one end, closed at the other). So for this section, we only look at open and closed intervals, but adapting to half-open intervals isn't hard.

Suppose that J is a nonempty subinterval of the real line with rational endpoints. For simplicity, let's assume that J is a subinterval of the positive real line. If it's not, then either it contains 0 — in which case 0/1 is the simplest fraction in J — or it's a subinterval of the negative real line and we can negate, find the simplest fraction, and negate back.

Then the following gives a simple recursive algorithm for finding the simplest fraction in J:

• If J contains 1, then 1/1 is the simplest fraction in J
• Otherwise, if J is a subinterval of (0, 1), then the simplest fraction in J is 1/f, where f is the simplest fraction in 1/J. (This is immediate from the definition of 'simplest'.)
• Otherwise, J must be a subinterval of (1, ∞), and the simplest fraction in J is q + f, where q is the largest integer such that J - q is still within the positive reals, and f is the simplest fraction in J - q.

For a sketch of proof of the last statement: if a / b is the simplest fraction in J and c / d is the simplest fraction in J - q, then a / b is simpler than or equal to (c + qd) / d, and c / d is simpler than or equal to (a - qb) / b. So b <= d, a <= c + qd, d <= b and c <= a - qb, and it follows that b = d and a = c + qd, so c / d = a / b - q.

In Python-like pseudocode:

This looks like a bug in the package, but it is related to the fact that your data are weird. This function is supposedly fitting distributions to observations of hydrological extremes: you have given it an integer sequence from 10 to 110.

As it turns out, when computing the fit for some of the possible distributions (P3 and GEV, I think), the function internally computes the skewness of the data and has a test for what to do if it the skewness is positive or negative. It doesn't consider the possibility that the skewness would be exactly 0!

Inside nsRFA:::ML_estimation:

You should use the bitwise NOT (~):

So after messing around, the answer seems to be very simple: `results1<-cj1["coefficients",]. This creates the list that I want. Akrun, if you read this, thank you for your support.

The following function adapts the code in this answer to a similar question.