@ecterrab 

Thanks., I followed the instructions, but it still hangs.

Rebooted the PC, started Maple and followed same instructions again and still hangs.

I am running windows 10, with latest updates. 

I did not make any other changes to my windows. 

If there is a log file kept during installation, I could look at it and see where/why it hanged but I do not know if there is such a file.

I'll wait and try the next version of physics updates, may be will have better luck with that. This is the first time it hanged during install for me.

version()
 User Interface: 1362973
         Kernel: 1362973
        Library: 1362973
                            1362973

kernelopts(version)
  Maple 2018.2, X86 64 WINDOWS, Nov 16 2018, Build ID 1362973

interface(version)

    Standard Worksheet Interface, Maple 2018.2, Windows 10, 

       November 16 2018 Build ID 1362973

Hello;

I've just updated my version 2018.2 using the "check for updates" option from the Tools-> menu to 2018.2.1 according to the post.

Now when I start Maple again, how does one verify they are running 2018.2.1?  It is still saying 2018.2 (without the .1 at the end)

I am assuming this minor version number should be given in the version number as well, else how would one know they are running 2018.2 vs. 2018.2.1 or 2018.2.2 etc...?

@Mariusz Iwaniuk 

Thank you for the workaround. Will use your workaround meanwhile, but I think it should not give exception if user do not provide the hint. Btw, to get simpler solution withtout the transforms, the following assumption helps.

sol:=pdsolve({pde,ic},w(x,t),HINT = `*`) assuming t>0;

Your PDE  has x,y as independent variables but your boundary conditions uses time?

PDE := (diff(u(x,y), x,x))-1/x*(diff(u(x, y), x)) -x^2*(diff(u(x,y), y,y))= 2;
BCs:=u(0,t) = 0, u(1,t) = 0;

@tomleslie 

you can give an answer without being such a rude person.

@Mariusz Iwaniuk 

Thanks. But assumptions are not needed in the product rule for logs. The rule is defined as is. Unless Wikipedia and all the books that list this rule are wrong ofcourse, which is a possibility.

@acer 

What is the reason for putting a NULL at last line of the proc?

I made small modification to your code, as I wanted the latex to be string.

restart:	
aliasedlatex:=proc(e)
local lookup;
lookup:=op(eval(alias:-ContentToGlobal));
return (:-latex(subs(lookup,e),output=string));
end proc:

This seems to work so far. But not sure why the NULL was there.

alias(C[1]=_C1):
aliasedlatex(1);
aliasedlatex(dsolve( diff(y(x),x)=1,y(x)) );

                              "1"
                "y \left( x \right) =x+C_{{1}}"

I found an answer, thanks to acer  which seems to do what I want. But I need to try it more to make sure.

https://www.mapleprimes.com/questions/204714-Alias-Surpress-Or-Declare-With-Latex-Outputs

restart;
aliasedlatex:=proc(e)
  local lookup;
  lookup:=op(eval(alias:-ContentToGlobal)):
  :-latex(eval(e,lookup));
  NULL;
end proc:

alias(C[1]=_C1):
sol:=dsolve(diff(y(x),x)=1,y(x));
aliasedlatex(sol);

               y \left( x \right) =x+C_{{1}}

which is what I want. This should be part of Maple itself. I do not understand why it is not. Or at least an option to latex() command.

@Joe Riel 

"Alas, the current design of odetest expects that integration constants are named with prefix _C"

Then why I can rename the constant to anything else in some other ode solution and it works just fine for odetest?

ode:=diff(y(x),x)=1+2*x;
my_sol:=y(x)=x^2+x+ C;
odetest(my_sol,ode);

            0

I can use "B" or "C[1]" or any other letter, and Maple is happy with it in the above example. odetest gives 0.  Maple own solution does use _C

dsolve(ode,y(x));
       y(x) = x^2+_C1+x

Are you saying it is hardcoded in some places and not in other places? 

This is all so confusing for a user who is trying to learn Maple.

@vv 

I am not able to follow what you are saying. 

I want 

RootOf(signum(0, _Z, 1));

to become

RootOf(signum(0, n, 1));

I read the help, but do not see why one can't do the above. (Maple help is really hard to follow. No example there for the 3 argument version for example. Maplesoft should invest some resources to improve help.)

It can be done using subs

expr:=RootOf(signum(0, _Z, 1));
subs(_Z=n,expr);

           RootOf(signum(0, n, 1))

Can't use subs, since do not know what the _symbol is before hand. This is just for formating purposes. I like to see "n" there instead of "_Z" when I print it.

@vv 

<"Blow-up" is not defined.>

Well, I guess Wikipedia and all the engineering Professors at my school who used this term have no clue what they are saying.

From https://en.wikipedia.org/wiki/Singularity_(mathematics)

The term blow up is a just a "loose" way to describe this and very common. At least in engineering.  As I said, there are other cases where a function is said to be singular at a point and the above article talks about those cases aslo. But the above is the most common one and what I was interested in when using singular for my needs. 

@vv 

I am using the basic definition of singularity: The points where the function  blows up. Sometimes called a pole also. I know there are different types of singularities and this can get complicated.

But I simply wanted to know the points where the function "blows" up. Excluding +- infinity.

So using this, the function sqrt(x) does not blow up (excluding +- infinity). singular does give these points correctly, but not discont(). At least not for every function I tried. So can't use discont() to find where the function "blows" up.

I like singular(), it works OK. Only question I had is about the real domain part. But it is not a big problem, as I could always filter out the complex poles it finds by post-processing the result. 

@Kitonum 

But this does not give singularites. Compare:

discont(sqrt(x),x);
          {0}
singular(sqrt(x),x);
                {x = infinity}, {x = -infinity}
 

Zero is not a singular point for sqrt(x). Sqrt(x) has no singularites (ignoring the +- infinities)

@vv 

I tried your function, but may be I am not using it correctly:

r:=singular(sqrt(x),{x});
cleanInfty(r);

              r := {x = infinity}, {x = -infinity}
                            {0 < 0}

I do not know why the function is returning 0<0. What does this actually mean?

putting r into a set or list, it gives error

r:=singular(sqrt(x),{x});
cleanInfty({r}); #same error with cleanInfty([r]);
Error, invalid input: cleanInfty expects its 1st argument, L, to be of type ({list, set})(relation), but received {{x = infinity}, {x = -infinity}}

I do not know how it worked in the first example above, since "r" is an expression sequence in that
case but cleanInfty is defined to take in a set or a list. But it did call it.

I was expecting to get an empty set or NULL from the above, since by removing all infinities, nothing is left. Am I using your function in the wrong way?

@Kitonum 

Thanks. But could you please explain to newbies why this works and not the other? I can't program like this, without an idea of why something works in one case and not the other, by using trial and error.

Also your adjustment, not do not now give same result as with x*ln(y)

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

While the earlier method from 

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

Worked on the above (but not on sqrt(x)*ln(y) )

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

The method needs to  work on all cases, since the function is not known before hand. 

Thanks