@michaelvio 

The vast majority of the slowness that you were experiencing was due to your use of int (symbolic integration) versus Int (numeric integration, when it's used in the context that you were using).

It's true that using a larger epsilon and a smaller numpoints will save some time, but that savings is infinitesimal in this case. I recommend that you remove both options so that those things will be done at their default values (although epsilon= 1e-6 is sufficient for plotting purposes).

You should also set Digits:= 15 right after the restart at the top of the worksheet. The extra precision makes a huge difference in the final plot, and the extra time needed isn't even noticeable.

To construct the function J1 as you just described, all that you need to do is

J1:= unapply(subs(x0= 1/t0, J), t0);

This is your last plot at the default Digits:= 10:

And this is using Digits:= 15:

It's a similar issue as with your recent Question regarding applying eval to Int or Intat: eval uses rules, usually to ensure the mathematical validity of the proposed substitution. The rule in this case is the procedure `eval/limit`. To create a more-sophisticated rule, read the procedure (showstat(`eval/limit`), it's a fairly easy read with only a moderate amount of Maple knowledge, and it's only 42 lines (Maple 2023)) and either write an overload or, perhaps, modify the procedure directly (ToInert, FromInert).

If you'd like it to follow rules additional to what's already in the procedure, and you can state them for me with a moderate amount of mathematical precision and generality, I may be able to suggest a way to code it. 

Let's consider your examples individually:

1. e:= A+B*limit(f(x), x= infinity);  eval(e, limit(f(x), x= infinity)= 1);
This case doesn't involve changing anything inside any limit. Thus, the rule isn't used (verified by using trace(`eval/limit`)), and you got your expected result.

2. e:= A+B*limit(2*f(x), x= infinity);  eval(e, limit(f(x), x= infinity)= 1);
In this case you're asking it to evaluate an expression containing a limit by using information about another limit (albeit, a very closely related one); the eval rule will be used. I think that the mathematical rule (i.e., abstract, not Maple) that you're implicitly invoking here is always valid, although I'm not 100% sure about all weird "corner cases", domains other than 2-sided real, and multivariate (more than one bound variable (e.g., limit(..., (x,y)= ...)) cases. That rule, stated generally, is that factors that don't depend on the bound variable(s) can be factored out of the limit. Command expand will do this, so a quick solution is 
eval(expand(e), limit(f(x), x= infinity)= 1)

[to be continued]

The correct command is is: 

is(sqrt(3) < 3);

Presumably it just expands things to a sufficient number of decimal places to make sure.

You wrote:

• Should one then use is(n>=m) instead of evalb(n>=m) always?

No! That's inefficient. evalb is builtin (kernel code rather than Maple). is is a highly symbolic command written in Maple. In the vast majority of cases, you know a priori that both sides are type numeric, and is isn't needed.

• I can also always apply evalf() on each side before. But this seems like an overkill to me.

I think that's the approach that is takes, and it might increase Digits if the user's set value is not high enough to make absolutely sure of the inequality.

I said that I could probably come up with something better for large n and m < < n, and here it is.

To make the algorithm fast, there are three things to avoid:

1. finding all the large prime factors of n when that is difficult to do,
2. finding all the divisors and then filtering them when the number of divisors is large,
3. checking every positive integer < m when m is large.

The command ifactors(n, easy) finds only the prime factors that are easy to find.

Download SmallDivisors.mw

This may be suitable for you:

select(`<`, Divisors(n), m)

Surely it's more efficient than what you were doing. For an easy-to-factor n >> 2^64 and m << sqrt(n), I could probably come up with something even better.

My guess is that you actually want the simplified product of an arbitrary number of factors of T[r]*P[r] --

T[1]*P[1]*...*T[n]*P[n]

-- because otherwise your Question would be exceedingly trivial. But first, you should stop trying to use an index (your r) as a parameter. Maple does allow the use of indices as parameters, but it's a somewhat more advanced topic than your current level of Maple knowledge. So, for now, let's just make r an ordinary parameter:

T:= r-> exp(r+1);  P:= r-> exp(r-1);

Your product can be represented as an inert product with the Product command:

Product(T(r)*P(r), r= 1..3);

Now, here's the non-trivial (but still conceptually easy) part: Make the upper bound, 3, arbitrary, and make the product non-inert by using product (lowercase):

product(T(r)*P(r), r= 1..n);

Of course that can be greatly simplified:

simplify(%);

By the way, can anybody give me an English word that's actually used in mathematical prose that completes this formal two-level analogy?:

(Addition is to summation as multiplication is to __?__)
as in Maple
(add is to sum as mul is to product).

That word, if it exists, would replace "products" in this Answer's Title.

Their are 9 vertices that I'll order top-down, left-to-right. That makes 18 variables. By making the lower right vertex the origin and the right edge the y-axis, we can make 5 variables 0. By reflecting the given image over the y-axis, we can constrain all points to the 1st quadrant. I generate 13 equations from the given information in your diagram, then use fsolve. The 13 equations are:

• Perimeters of each of the 7 primary triangles
• Perimeters of the 2 composite triangles
• Collinearity of the left side (2 equations because it's 4 points)
• Collinearity of the bottom side
• Collinearity of the bottoms of the triangles with perimeters 9 and 12.

I'll leave it to you to color them.

Download TrianglesByPerimeters.mw

Your initial expression V__phi has a pair of square brackets [ ]. These need to be replaced by round brackets ( ) (also known as parentheses). In Maple (and most computer languages) square brackets can't be used as a "higher level" of parentheses like they are used in math books. Only parentheses can be used for algebraic groupings.

Making this change, the whole expression simplifies quickly.

You can use Edit ==> Find from the menus to find the square brackets.

The read command is for reading files of plaintext Maple code, not Maple worksheets. The file that you tried to read, "EKHAD.mw", is a worksheet. You should open it like you'd open any other worksheet: through the File ==> Open menu dialog.

The first read command that you gave has already loaded the code. Just type

ezra();

I believe that many of the algorithms from A=B have been directly implemented in Maple already.

The difference between eval (in its form used in this Question) and subs is that eval follows rules that are often specified in Maple code. The rule in this case is the procedure `eval/Int`. Presumably this procedure has been updated since Maple 2015. After a restart (to clear remember tables), do

trace(`eval/Int`);

and rerun your problem.

This should work for all your cases:

SeriesInt:= e->
    subsindets(
        e, specfunc({Int, int, Intat, intat}),
        J-> op(0, J)(mtaylor(op(1, J), op([2,1], J)= 0, 5), op(2.., J))
    )
;

The suggestion by @dharr will work in most cases. But it won't work when the subscript is an integer because then the subscript will be interpreted as an index into the list on its left. The command Typesetting:-Typeset can be used to turn mathematical expressions into inert objects that display exactly like the original expressions. So, this works:

restart:
`print/SubSup`:= (e, a, b)->
    [e][Typesetting:-Typeset(a)]^Typesetting:-Typeset(b)
:
SubSup:= (e::uneval, a, b)-> 'procname'(e,a,b)
:
SubSup(int(x^2, x), 2, 5);

 

The plot command is only for 2D. For 3D, use

plots:-spacecurve([t*sin(t), t*cos(t), (2*sqrt(2))/3*t^(3/2)], t= 0..Pi);

For 2D (assuming (just to keep this Answer simple) the orthogonal projection into the xy-plane), use

plot([t*sin(t), t*cos(t), t= 0..Pi]);

Note that in the first command, the range t= 0..Pi is outside the square brackets, and in the second command, it's inside.

(simplify@eval)(
    sqrt(a^2+b^2),
    solve({d-b = c-d, a/d = tan(45*Pi/180), a*(c-b)/2 = 60, a^2+c^2 = 19^2})
);
                               11

The variables s, x, and y are clearly irrelevant because they only appear once in the problem.

Since the constraints are all easily made polynomial, this works also:

(simplify@@2)(
    sqrt(a^2+b^2), 
    {d-b = c-d, a/d = tan(45*Pi/180), a*(c-b)/2 = 60, a^2+c^2 = 19^2}
);
                               11

This form of simplify requires only the constraints, not the objective, to be polynomial, or easily convertible to polynomial (as in a/d = ...). It's help page is ?simplify,siderels.

The extra simplify (as in simplify@@2) is unfortunately required to simplify sqrt(121) to 11. To avoid that awkwardness, you could do this:

(sqrt@simplify)(
    a^2+b^2, 
    {d-b = c-d, a/d = tan(45*Pi/180), a*(c-b)/2 = 60, a^2+c^2 = 19^2}
);
                               11

The other responders are making the mistake of assuming that all the variables are integer. The problem only requires AD to be integer. On a number line, let A, B, C, D = 0, 7/3, 20/3, 21/3. Then AD = 7.

This is an excellent problem for testing any mathematical natural-language AI system. Solving it requires more than just middle-school Algebra I. This is a GRE-level problem (admittedly a fairly easy one). (GRE = Graduate Record Exam, a nationally standardized exam that one takes in the U.S. before applying to graduate school.)

@mmcdara In English, there is no ambiguity or lack of precision in this problem's statement. "Consecutive" means that they are distinct points, and are in the stated order. "Confounded" is not a word used in ordinary mathematical English; its only common usages are to describe mental states.

The diagram has two quadrilaterals that I'll call the "kite" and the "dart". They share two sides. I'll label these points as vertices:

• A: point at the 60-degree angle
• N: point where n is used
• C: point in center where two lines cross
• M: point where m is used
• X: point where x is used.

The kite is ANCM; the dart is XNCM. Now make two equations using that the sum of the angles of a quadrilateral is 360 degrees.

#quadrilateral ANCM:
Kite:= 60 + (180-2*n) + (180-40) + (180-2*m) = 360;
#       A       N           C          M
                 Kite := 560 - 2 m - 2 n = 360

#quadrilateral XNCM:
Dart:= x + n + (180+40) + m = 360;
#      X   N       C      M
                 Dart := x + m + 220 + n = 360

x = eval(x, solve({Kite, Dart}));
                             x = 40