@mapleatha If you construct a sum of n terms, and 1 of those terms automatically simplifies to 0, then the sum will have n-1 operands. If two of those terms cancel each other, then it will have n-2 operands. In either case, if the final result has only 1 term, then the meaning of "operand" as used by op changes. In other words, when terms become 0, they "leave no trace".

It is for reasons such as those that last week I told you that your usage of op to deconstruct differential operators expressed as polynomials in D was "very cruddy and prone to error." I meant nothing personal by that, and I wouldn't expect you or anyone to have known that already. In addition to the problems mentioned in the first paragraph, that particular usage of op had numerous other potential errors. IMO, these problems are beyond any possibility of repair; two-argument op applied to sums simply shouldn't be used for these purposes. I said that you mustn't do this or ask about it again because it'd be an utter waste of your time to try to fix something that can't be fixed. But if you want to discuss alternative methods for working with polynomials or differential operators, that's fine.

I made your question to acer regarding deleting bad characters from worksheets into a separate Question thread. It was not related to the subject of this thread. Threads are organized by the subject, not by the names of the correspondents. In other words, this is not a "chat room".

@nm My comment was directed at the OP, not at you. If it had been directed at you, it would've started with @nm . I agree with what you said about series.

@Thomas Dean You (as well as isolve) are interpretting "solution" to mean any 4-tuple (a, m, n, x) of integers that satisfy the equation. It's obvious that given any integers a and x with a <> x we can find a 1-dimensional infinite family of pairs of integers (m, n) such that (a, m, n, x) satisfy the equation. However, that's not what the OP means by "solution". By "solutions" they mean the values of x alone. Given any (a, m, n) with a <> 0, the resulting equation is quartic in x. The OP wants to know if that quartic has 4 integer solutions for x.

@greatpet The behavior of series is exactly the opposite of what you say. The order argument does specify (one more than) the maximum power. It does not specify the number of terms.

@tomleslie Vote up.

If someone wants an alternative with much less typing, at the expense of slightly more-complicated code, do this:

(f, g, h):= (0.5*x, sqrt(0.81-(x-2)^2), sqrt(3.57^2-(x-8)^2));
plots:-display(
    Student:-Calculus1:-SurfaceOfRevolution~([f,g,h], x= 0..10, output= plot),
    transparency= 0.5, scaling= constrained, color= [red, green, blue],
    caption= `` 
);

@nm On the help page ?rtable_indexing, in the section "Selecting Elements: Extracting Subblocks", the 4th paragraph is

• The result of subselection A(i1, i2,  .. , iN) on an N-dimensional array is not the same as the indexing with square brackets.  In this case, the number of dimensions of the result will correspond to the location of the last non-singleton index.  That is, if the ith index is the last non-integer index then the result will have i dimensions.

I think that this completely addresses the Question at hand. However, why this design decision was made is another matter.

@AHSAN In that case you use

for n from 20 to 30

I don't think that you understand what "default" means. It means a value that will be used if and only if no other value is given. If a value is given, it takes precedence over a default. 

@AHSAN 

The from clause of a do loop is optional and defaults to from 1. Indeed, all clauses of a do loop are optional (for, from, by, to, in, while, until).

@tomleslie It's clear from the title that the OP wants to integrate with respect to time, not distance.

@Carl Love 

Here's another way that uses a feature of int that is added by loading the Units:-Standard package:

with(Units:-Standard): 
Int(10*Unit(m/s^2), t*Unit(s));
value(%);

The reason that I didn't mention this before is that the inert Int gets prettyprinted in an inelegant way, which you'll see when you execute the code. This inelegancy only affects the display, not the computation. Despite that, it seems the closest to what you were trying. Still, I'd use the Intat.

@acer 

The reason that I didn't use Typesetting is that the objects it produces are type function, not type symbol or name. Thus there are numerous contexts where they can't be used, such as a variable of integration; and there are other contexts where they silently behave in different and undocumented ways, such as a bound variable in solve.

@Johan159 

Yes:

phi:= `#mo("phi", mathcolor= black)`;

@Gillee Considering the extent of programming involved in this Answer and the degree of efficiency improvement attained, I think that it deserves a Vote up (thumb icon in upper right corner).

I realized that compiled code recognizes parity checks (::odd, ::even), and by using these as a replacement for mod 2, I reduced the total time to 7 seconds. Again, that's the total time using a single processor. It should be possible to parallelize this (e.g., rowwise), but I have yet to get it to work with Threads.

I also added comments that explain the arithmetic.

restart
:
BuildA_M:= proc(
    A::Array(datatype= integer[4]), M::Array(datatype= integer[4]),
    r::integer[4]
)::integer[2];
local 
    i0::integer[2], i::integer[2], j0::integer[2], j::integer[2],
    m::integer[2], t0::integer[2], t::integer[2],
    p::integer[2], #parity (1=even, 0=odd) of 1 bits in a word
    Z::integer[2] #count of 0s
;
    for i0 to r do for j0 to r do
        Z:= 0; 
        for t0 to r do
            p:= 1; i:= i0-1; j:= j0-1; t:= t0-1; m:= M[t0];
            while i*t <> -j*m do #i.e., while they're not both 0
                #The effect on the low-order bit of the operation i*t-j*m is
                #equivalent to that of the operation Xor(And(i,t), And(j,m)).         
                if (i*t - j*m)::odd then #low bit = 1
                    p:= 1-p #Switch parity of count of 1-bits. 
                fi;
                i:= i/2; t:= t/2; m:= m/2; j:= j/2 #integer divisions!
            od;
            if p=1 then Z:= Z+1 fi
        od;
        A[i0,j0]:= Z
    od od;
    0
end proc
:
BuildA:= Compiler:-Compile(BuildA_M):

LArip:= proc(n::posint)
local 
    r:= 2^n, 
    M:= Array(1..r, combinat:-randperm(r) -~ 1, datatype= integer[4]),
    A:= Array((1..r)$2, datatype= integer[4])      
;
    BuildA(A, M, r);
    (A, M)  
end proc 
:
(A,M):= CodeTools:-Usage(LArip(8));
memory used=287.77KiB, alloc change=0 bytes, 
cpu time=7.06s, real time=7.07s, gc time=0ns

@Carl Love My code above can handle your longer example just as well:

str:= "A": s1:= " some very long string here":
s2:= " it was%s 10 ": s3:= "another very long string": 
x:= 10:
str:= sprintf(cat(str, s||(1..3)), if x++=10 then "" else x:=9; " not" fi);
x;
  str := "A some very long string here it was 10 another very 
     long string"

                               11