One of the basic techniques of computer algebra is to solve the same problem several times over different prime fields and then "lift" those solutions to the integers. There are several algorithms for the lifting. Here, I use the oldest and most well known: Chinese remaindering (see help page ?chrem).

The code below finds an 20-digit (67-bit) value of d in 2.3 seconds. That's larger than wordsize. This only requires 13 primes, all less than 80. It attempts only 619 factorizations over finite fields and 13 irreducs over the integers.
 

Download ChineseLifting.mw

If the result containing xs were named res, you could do

eval(res, x= x(t))

There are some shorter and cruder possibilities for your particular example, but they won't work for more complicated examples.

When you get a non-smooth implicitplot, the first thing to try is the gridrefine option. It's a positive integer defaulting to 1. Here, I've set gridrefine= 3 for your plot:

The minimum is 0 at a=0; the value of x is irrelevant. It's not a local minimum because a=0 is one of the boundaries. This can be confirmed by simple plotting:

plot3d(f, 2..5, -1..0)

An iron-clad proof that this is the minimum will be harder to obtain.

So, the Optimization package was more accurate in this case.

Here is VV's algorithm as a predicate (i.e., returns true or false) procedure. This doesn't rely on the vertices being numeric and tries to do a minimal amount of copying:

IsOuterplanar:= proc(G::Graph)
uses GT= GraphTheory;
    GT:-IsPlanar(GT:-GraphJoin(G, GT:-PathGraph(1)))
end proc
:

The cases that don't work via a direct built-in distributive property can be done with map:

e:= a <= b;
map(exp, e);
map(`/`, e, -2);

Caution: This works regardless of whether the results are mathematically valid.

Many of these distributive properties are documented at ?evalapply.
 

Using solve(..., parametric), a definitive programmatic solution can be obtained in Maple 2019:

f:= 2*x^5-x^3*y+2*x^2*y^2-x*y^3+2*y^5;
solve({f, x < 0, y < 0}, parametric);
      [ ]

Note that those brackets won't be empty if either or both inequalities are reversed.

The parametric option only works for polynomial systems and systems that can be easily reduced to polynomials.

I find ColumnGraph difficult to use when you have non-categorical horizontal-axis data (such as real-number measurements), and it becomes clear that this wasn't its intended usage. Instead, it can be done with a regular plot command like this:

plot(
   ((x,y)-> [[x,0],[x,y]])~(yr, sle), 
   thickness= 70, xtickmarks= yr, view= [0..0.35, DEFAULT]
); 

The colors can be easily changed if you want.

Just include fclose("input.txt") in the procedure.

I think that in most languages, most opened files stay open until they are explicitly closed.

Here is a much-faster and slightly more accurate way to solve the BVP by finite-difference methods. This is a method that I just came up with: Start by approximating the function value at the midpoint of the interval. So now we have two subintervals of length (c-a)/2. On each iteration:

1. Divide all subintervals in half.
2. Approximate the function value at each odd-numbered node (the s[k]) using the even-numbered nodes (s[k-1] and s[k+1]) adjacent to it, which have already been approximated. The odd-numbered nodes are the midpoints of the new subintervals.
3. Use fsolve on the entire set of finite-difference equations to refine the approximations (both odd and even nodes), using the existing approximations as initial guesses to fsolve.

This method is limited by the fickleness of fsolve. In actual practice, I'd code a Newton's method solver to take the place of fsolve for this. Nonethless, the worksheet below gets a 127-point solution in a few seconds with a maximum absolute error of 6e-7, (or 9 significant digits). That's pretty good!
 

Download BVP_FDM.mw

This is how I like to do a finite product (and it works just as well for add and seq as for mul) that uses all indices except for a specified one. The specified one in this example is i.

i:= 3:  n:= 5:
mul(1/(x[i]-x[j]), j= [$1..i-1, $i+1..n]);

This works even when i is 1 or n.

Another version:

i:= 3:  n:= 5:
mul(1/(x[i]-x[j]), j= {$1..n} minus {i});
 

Your ode is a quadratic expression in diff(sr(r), r$2)---it's highest-order derivative---and thus it's really two odes, one for each solution of the quadratic. Once you isolate these two branches, it's trivial and very fast to solve each with Maple's BVP solver available through dsolve(..., numeric).

Your solution is sufficiently accurate (shown below), although your technique is doomed to be slow due to symbolic expression swell.
 

Download 2branchBVP.mw

Just do

plots:-odeplot(F, [x(t),y(t),z(t)], t= 0..2);

You can change the range 0..2 to any finite real interval.

We've had an interesting discussion here exploring the purely mathematical and computational details of fitting a polynomial to historical data. But the practical details are that you're trying to model annual sales of oatmeal products. This polynomial model (or any polynomial model) is utterly worthless for predicting future sales: They cannot model the cyclic variation that's evident in your data. Assuming that the cycle is not just randomness (and there's really not enough data to assume even that), it appears to have a period of four years and no growth trend. A sinusoidal model would be more appropriate, but I don't think there's enough data to fit it.

Taking a wild guess: Oatmeal sales are higher in years with Winter Olympics when your company sponsors "home-country hero" athletes who eat a lot of healthy oatmeal. So, find some effective way to advertise in the other years.

Your proposed solution can be immediately seen to be wrong for two obvious reasons:

1. W is a function of two variables, so W' is meaningless.
2. Your solution doesn't contain the derivative of Y.

D[1](w) refers to the first partial derivative of w with respect to w's first parameter. D[2](w) is the first partial derivative with respect to w's second parameter.