There are internal routines of SolveTools:-Inequality , for linear systems, which are unprepared for arguments that contain relations which are a function of `<>`.

After such `<>` relations are generated internally, then as they get passed to such an internal procedure then that kind of error message attains.

I can reproduce the error message you've seen. (I edited the inequalities in your Question, and inserted a missing comma after what is now the first in your list.)

I did a cursory look through the related internal routines, and did not see any obvious reason why they shouldn't be able to handled `<>` present in their primary input. But I see one of two things which make me a little suspicious. If I simply change the parameter specification of those procedures to allow `<>` alongside the other kinds of relation in the input then I so obtain some result for your system.

It is not as quickly solved as the new system generated from the substitutions you suggested. I am unsure of the best way to try and verify whether the two answers (when re-expressed in the original variables, say) represent the same solution space.

Download ineqsystem.mw

If plots:-inequal is correct (especially in its lines) above then there may be some discrepencies in some part of the computed distinction between inequality and strict inequality. It might be better/necessary to have the altered routines convert all `<>` relations into alternate form, as their very first step.

A := unapply(eval(C(2,3),:-t=T),T):

A(0), A(0.5), A(0.3);

It would be less awkward if you did not have the unnecessary creation of Ld as an operator (using unapply) inside the procedure C., as well as not assign to Ld(t)[i]. I suspect that does not accomplish what you're expecting.

restart;
with(LinearAlgebra):
C:=proc(k,M) local N,P,m,L,T,j,Ld,n,i; 
N:=2^(k-1)*M:
P[0]:= t -> 1:
P[1]:= t -> t:
for m from 2 to M-1 do
   P[m]:= unapply(expand((2*m-1)*t*P[m-1](t)/m - (m-1)*P[m-2](t)/m), t)
end do: 
L:=proc(n,m) local a,b; 
  a := (2*n-2)/2^k; 
  b := 2*n/2^k; 
  return piecewise(a <= t and t <= b, P[m](2^k*t-2*n+1)*sqrt(((m+1)/2)*2^k))
end proc:
T := Vector(N):
for j from 1 to N do T[j] := (j-1/2)/N end do; 
Ld := Vector(N);
for n from 1 to 2^(k-1) do 
  for m from 0 to M-1 do
i := n+2^(k-1)*m:
Ld[i] := L(n,m)
     end do
end do:

return Ld:  
end proc:

A := unapply(C(2,3),t):
A(0), A(0.5), A(0.3);

What do you want to accomplish with PDEtools[PDEplot] ?

The plots below render more nicely in the actual Maple GUI.

Download pdeplot.mw

I have tried to un-muddle the code you supplied.

Download sinc_method_example_ac.mw

restart;

C := [0,1/11],[1/11,1/9],[1/9, 1/7],[1/3,1/2],[1/2,1]:

op(map(`[]`@op,[solve(Or(op(map(r->__dum>=r[1] and __dum<=r[2],[C]))))]));

                         [   1]  [1   ]
                         [0, -], [-, 1]
                         [   7]  [3   ]

lprint(%);
  [0, 1/7], [1/3, 1]

Download solve_integer.mw

We can generate results for each a,b pair via a pair of nested seq calls. And we can accept or reject such candidates according to whether they each pass a conditonal test within the procedure which generates them.

Naturally, you could add whatever else you want to the conditional test (if...then) within procedure G. (note: the restrictions you were originally placing on a,b,x,y don't seem to follow from the problem description you gave. I mean, where you had nops({a, b, x, y}) = 4 and x*y*a*b <> 0)

Download solve_integer_2.mw

Here is one way.

student_md_question_ac.mw

You can find several older posts on this topic by searching this site for the word colorbar. Eg, [1], [2], [3] .

The 2+3 becomes 5 due to automatic simplification. That's not something that's going to be able to help you with your second example.

One way to construct a procedure (operator) from a given expression is to use the unapply command.

example2 := unapply( int(1,y), x );

                       example2 := x -> y

example3 := unapply( int(sin(x*y),y), x );

                                     cos(x y)
                  example3 := x -> - --------
                                        x    
example3( 17 );

                           1           
                         - -- cos(17 y)
                           17          

One way is to pull the units out of the the two columns, separately.

You haven't told us what units you want have for the results. Is it foot and day?

Download plot_column_units.mw

Which level did you use for the interface setting prettyprint? Was it 0, or 1?

I have been seeing weird behavior with interface(prettyprint=0) for a while now, when using the Standard GUI.

So it you are trying to use writeto from within the Standard GUI (and presuming you are not just using printf calls) then you might want to see if you can get by with the setting interface(prettyprint=1) .

This looks kludgy at best, and perhaps suspect at worst, but for this example...

Download kludge.mw

[edit] I think that I prefer the following form, with radnormal as an intermediate step, since the following form behaves nicer under simplify.

You can use the print command.

You could simply use rand here.

restart;

LetList := [C, E, F, H, K, P, T, W, X, Y]:

gen:=rand(1..nops(LetList)):

gen();
                               7

LetList[gen()];
                               Y

LetList[gen()];
                               P

LetList[['gen()'$5]];
                        [E, H, P, K, C]

It is, of course, trivial to scale the results below by the appropriate 1/2^k , simply by multiplying the generated Matrix by that factor. Or you can scale the two Matrix arguments passed into the procedure Gen.

Download block_band_matrix.mw

Using Maple 2015.2,

convert(hypergeom([a, b], [c], 1), StandardFunctions);

                   GAMMA(c) GAMMA(c - a - b)
                   -------------------------
                   GAMMA(c - a) GAMMA(c - b)

convert( hypergeom([a, b], [c], 1), GAMMA_related );

                   GAMMA(c) GAMMA(c - a - b)
                   -------------------------
                   GAMMA(c - a) GAMMA(c - b)

Also,

restart;

kernelopts(version);

    Maple 2015.2, X86 64 LINUX, Dec 20 2015, Build ID 1097895

 simplify( hypergeom([a, b], [c], 1) );

              GAMMA(c) GAMMA(c - a - b)
              -------------------------
              GAMMA(c - a) GAMMA(c - b)

restart;

kernelopts(version);

    Maple 18.02, X86 64 LINUX, Oct 20 2014, Build ID 991181

simplify( hypergeom([a, b], [c], 1) );

              GAMMA(c) GAMMA(c - a - b)
              -------------------------
              GAMMA(c - a) GAMMA(c - b)

I don't understand why some of your Questions are marked as Maple version 2015, and some with version 18, and some with 2018.