singular(ln(y^2+1),y);

        {y = -I}, {y = I}, {y = infinity}, {y = -infinity}.

But if "y" was real, then there are no finite singularities, since y^2 is always positive and hence y^2+1>0 always. Adding assumptions did not help

singular(ln(y^2+1),y) assuming y::real;

gives same result. RealDomain does not support singular.  But I am no longer using RealDomain as it seems bugy.

I know I could filter out these complex results using remove(), but it would be nice if there was a way to singular supports assumptions. Is there a way to do it?

Why are the following 2 commands produce different result?

restart;
RealDomain:-solve({y=y,y<>0},y);
solve({y=y,y<>0},y);

                            [y = 0]
                            {y <> 0}
 

Should not the result be the same?

solve({y=y,y<>0},y) assuming y::real;
                           {y <> 0}

Maple 2018.1. 

Are these errors to be expected? Why do they happen?

restart;
solve({x<>10, -infinity<x , x<infinity, -infinity<y , y<infinity},{x,y});

Error, (in solver) invalid input: SolveTools:-Inequality:-LinearUnivariateSystem expects its 1st argument, eqns, to be of type ({list, set})({`<`, `<=`, `=`}), but received {x <> -infinity, x < 10}

But it works when replacing x<>10 by y<>10

restart;
solve({y<>10,-infinity<x , x<infinity, -infinity<y , y<infinity},{x,y});
            {10 < y, x < infinity, y < infinity, -infinity < x}, {y <> -infinity, x < infinity, y < 10, -infinity < x}

What is the difference in the above two?

It also work when replacing x<>10 by x=10

solve({x=10, -infinity<x, x<infinity, -infinity<y , y<infinity},{x,y});
               {x = 10, y < infinity, -infinity < y}

It also works when removing the y parts by keeping x<>10

solve({x<>10, -infinity<x , x<infinity},{x,y});
           {y = y, 10 < x, x < infinity}, {y = y, x < 10, -infinity < x}

it also works when removing x<>10 and putting back the y stuff

solve({-infinity<x , x<infinity, -infinity<y , y<infinity},{x,y});
              {x < infinity, y < infinity, -infinity < x, -infinity < y}

Why Maple gives an error for some cases and not the others?

Maple 2018.1

I was trying the solution given in 

https://www.mapleprimes.com/questions/225083-Maple-Command-To-Find-Domain-Of-Function

Which works fine for some functions, but fail for some reason for other functions.

restart;
f:=x*ln(y);
solve(evalc(Im(f)), {x,y});

But fails on 

restart;
f:=sqrt(x)*ln(y);
solve(evalc(Im(f)), {x,y});

Using Maple 2018.1 with Physics 

`2018, July 3, 20:10 hours, version in the MapleCloud: 78, version installed in this computer: 74`

Why this error happen on some functions? Is there a way around it?

One way to workaround it I found, is to use solve for one variable at a time. Now Maple do not give an error

restart;
f:=sqrt(x)*ln(y);
solve(evalc(Im(f)), {x});
solve(evalc(Im(f)), {y});

Strange it failed when using {x,y} at same time on this one, but not on the first one. But the above answer is wrong. For "x", it should be x>=0 and not x=0. If I remove the "y" now it gives correct answer

restart;
f:=sqrt(x)*ln(y);
solve(evalc(Im(f)), {x});

f:=sqrt(x);
solve(evalc(Im(f)), {x});

This makes no sense to me.

I am finding too many bugs in Maple making it not useable and having to keep coming with workarounds. 

Maybe it should be tested more thoroughly before release.

When I run a proc, I get an error

Error, (in SolveTools:-Inequality:-Piecewise) piecewise takes at least 2 parameters

But when I do restart; and then run the same command where the error was generated from inside the proc, but outside the proc, I get no error.

So I did not understand why it fails inside the proc, as I am typing the same exact command.

It turned out that an internal symbol _Z1 must have got messed up due to earlier calls made in the proc. It seems to have assumptions on it. To show this, here is screen shot. Only when I cleared the assumptions on _Z1, did it work. I do not use _Z1 any where in my code. This came back from a Maple call.

Now to proof this:

restart;
assume(_Z1::integer);
solve({x <> (  (1/2)*Pi+_Z1*Pi ), x < infinity, -infinity < x},{x})
 

I never set _Z1 myself in my code. This was done by Maple internally somewhere and caused this error. In my proc, I made call to singular and to solve only. And noticed this problem. 

What should I do to avoid this problem? Why Maple fails above when its own _Z1 symbol is assumed integer? Is this a bug?

As a workaround for now, I could do this

_Z1:='_Z1'; #when I clear this, the error goes away. Why?
sol:=solve({x <> (1/2)*Pi+_Z1*Pi, x < infinity, -infinity < x},{x}):
simplify(sol) assuming _Z1::integer;

ofcourse,  I do not know that Maple will use _Z1 all the time, since I have to hardcode this in the code for now to pass through this problem. So this is a temp. solution for me.