@Kitonum Yes, certainly your first version is easier to understand than mine. (My primary motivation is usually avoiding repetition.) Your second version is fine for a very smooth curve, as shown, but probably not so great for a less smooth curve. 

@Joe Riel Vote up. I've used the types And(specfunc(...), patfunc(..)) and And(typefunc(...), patfunc(...)) so many times that I wonder why there's not a predefined single type that does it.

@imparter Like this:

plots:-display(
    map(
        L-> plot(sin(x), x= -Pi..Pi, L[]),
        [[linestyle= solid],
         [style= point, symbol= box, numpoints= 16, adaptive= false]
        ]
    )
);

The fact that the options stepsize and minstep exist suggests that there are known to be cases where they are needed to get accurate results. 

@RohanKarthik 45*x does not satisfy the condition degree(..., x) - degree(..., y) equals 0 or -1.

@Yiannis Galidakis When y is integer, there are many variations possible for the depth of the evaluation. One possibility is to have hy(5, 2, 4) return 2^(2^(2^hy(4, 2, 65533))). Of course, you want to avoid towers of exponents that are too tall to display.

@Yiannis Galidakis The following should work in Maple 13. It only took me 5 minutes to make the changes.

`print/%^`:= (a,b)-> ``(a)^b:
`print/%*`:= (a,b)-> ``(a)*``(b):
`value/%^`:= `^`:
`value/%*`:= `*`:

hy:= proc(n, x, y)
    if n=0 then y + 1
    elif n=1 then x + y
    elif y=0 then 1
    elif y=1 then x
    elif n=2 then `%*`(x,y)
    elif n=3 then `%^`(x,y)
    elif n=4 then 
        if y::posint then `%^`(x, procname(4, x, y-1))
        else `%^`(x, 'procname'(4, x, y-1))
        fi
    elif [n,y]::list(posint) then procname(n-1, x, procname(n, x, y-1))
    else 'procname'(n-1, x, 'procname'(n, x, y-1))
    fi
end proc
:
hy(4, 2, 4);
value(%);
                             65536

@Yiannis Galidakis Your code in the Reply immediately above makes no distinction between numeric and symbolic y, and thus I can't see how it addresses your Question about recursion. Rather than retrofitting my code to Maple 13, it seems like you're ignoring its most important features.

For how long will you be stuck with just Maple 13?

Like I've told you before: When you say that something is not working, show an example of it not working, not just an example of it working! It's okay to show an example of it working if in addition you show an example of it not working.

@dharr Note that in the case of GaussianElimination and LUDecomposition and other "solver" commands, FractionFree refers to the workings of the algorithm, not its output. The output may necessarily contain fractions.

@Scot Gould This issue is caused by an unfortunate ambiguity in the syntax for DataFrame indexing. They can be indexed with positive integers as if they were matrices, or they can be indexed by labels. This causes problems when you use labels that can be mistaken for ordinary indices.

@Ali Hassani Yes, but that lacking in Maple has nothing to do with symbolically solving a single equation or a single system of equations since (as far as I know) there doesn't mathematically exist any parallel algorithm to do it! If the algorithm exists, it is very likely that it can be implemented in Maple.

If you wish to apply the parentheses-adding operator `` to all the items of a list L (of polynomials or anything else), you can do ``~(L). 

@Hitch_Hawk You're welcome, and please don't hesitate to ask other similar questions.

To use a shooting method, there must be two boundary points, and the differential order must be at least two.