Given a system of 2 first order ode's which are autonomous (i.e. the RHS does not explicitly depend on time), one can make phase plot in Maple using DEtools:-DEplot

I am trying to get my Maple output to look like I get with Mathematica. I am getting close, but there are two issues. First, here is what I get in Maple

restart;

ode1:=diff(x(t),t)=2*x(t)*y(t);
ode2:=diff(y(t),t)=1-x(t)^2-y(t)^2;

DEtools:-DEplot([ode1,ode2],[x(t),y(t)],
                           t=0..1,x = -4..4, y = -4..4,arrows=curve,linecolor=red,
                           numpoints =300,arrowsize='magnitude',scene=[x(t),y(t)]);

Here is the same thing in Mathematica

ode1=x'[t]==2*x[t]*y[t]
ode1=y'[t]==1-x[t]^2-y[t]^2

StreamPlot[{2 x*y,1-x^2-y^2},{x,-4,4},{y,-4,4},
    FrameLabel->{{y[t],None},{x[t],None}},BaseStyle->16,ImagePadding->{{50,10},{50,0}}]

Is it possible to get the arrows to be stream lines similar to how they show up? Also, the axes labels in Maple are internal and hard to see. Is it possible to have on the outside like above so they are easier to see?

On a side question: Should one use DEtools:-DEplot or DEtools:-phaseportrait I could never understand when to use one vs. the other.

Maple 2023.2 on windows

May be someone could help me understand the logic that Maple goes through in this example.

restart;
ode:=diff(y(x), x) = sqrt(y(x))*sin(x);
dsolve([ode,y(0)=0]);
dsolve([ode,y(0)=0],'implicit');

For first dsolve it returns y(x)=0 and for the second it returns what is expected which is sqrt(y(x)) + cos(x)/2 - 1/2 = 0

Why this difference in result? Just trying to understand the logic behaind it. 

Maple 2023.1 on windows 10

Download why_dsolve.mw

This setup works, where B extends A, then B method access local variable in A directly, since it now becomes part of the object B itself

restart;
                            
module A()
  option object;
  local s::string:="";
end module;

module B()
   option object(A);
   export foo::static:=proc(_self,$)
      _self:-s := cat(_self:-s,"something");
      print(_self:-s);
   end proc:
end module;

o:=Object(B);
o:-foo()

Gives "something"

Now, I changed B, by adding an anonymous local proc() and did the same exact thing as above, which is to access s.

Now Maple complains that B does not export s

restart;

module A()
  option object;
  local s::string:="";
end module;

module B()
   option object(A);
   export foo::static:=proc(_self,$)
        proc()
            _self:-s:=cat(_self:-s,"somethig");
            print(_self:-s);
        end proc();
   end proc:
end module;

o:=Object(B);
o:-foo()

It gives

Error, (in anonymous procedure called from anonymous procedure) module `B` does not export `s`

Could someone help me understand why this happens? How it works in the first example but not in the second?  I do not see why it would make difference. isn't anonymous procedure part of the class that is being extended?

Update

It is worst than I thought. Even named local proc, inside method now fail. Here is an example

restart;

module A()
  option object;
  local s::string:="";
end module;

module B()
   option object(A);
   export foo::static:=proc(_self,$)
        local z::string:="something";
        local my_inner_proc:=proc()
            _self:-s:=cat(_self:-s,z);
        end proc();
        my_inner_proc();
   end proc:
end module;

o:=Object(B);
o:-foo()

Gives 

Error, (in anonymous procedure called from anonymous procedure) module `B` does not export `s`
I was using code which worked before, but now after extending the class, I am finding all these problems.

Is this documented something that local proc()'s inside method do not work as expected when extending classes in Maple OOP? It means now I have to move these local proc() to the outside of its current enclosing proc() to make Maple happy.  I just do not understand why this limitation.

Maple 2023.1 on Windows 10

integral of sqrt(sin(x)) is known to be as given in few place such as in here and other places.

Maple gives a result which is much more complicated (but also in terms of EllipticE special function). 

Could someone find a way to simplify it to the above answer and also to the same answer given by Mathematica?

int(sqrt(sin(x)),x)

Compare to 

Maple's result seems to be correct, as I plotted it and compared the smaller known resut. But I was not able to simplify it to obtain the smaller antiderivative.

Any tricks to do that?

Maple 2023.1 will not let me overload a method for an object when using _self.  Is there a way around this?

module person()
   option object;
   local the_name::string:="*",the_age;

   export set_info::static:= overload(
   [
      proc(_self,the_name::string,$) option overload;
          _self:-the_name:=the_name;
      end proc,

      proc(_self,the_name::string,the_age::integer, $) option overload;
          _self:-the_name:=the_name;
          _self:-the_age:=the_age;
      end proc
   ]);

   export get_name::static:=proc(_self,$)
      RETURN(_self:-the_name);
   end proc;
end module;

And now when I do 

o:=Object(person);
o:-set_info("me");
o:-set_info("me",20)

Error, (in person:-set_info) `me` does not evaluate to a module
Error, invalid input: no implementation of person:-set_info 
matches the arguments in call, 'person:-set_info("me",20)'

The problem goes away by removing `_self` as first argument in signature of the overloaded method. But then I will not be able to use _self any more inside the methods.

There is no problem overloading the method when using normal module, or one that does not use _self. For example this works

restart;

module person() 
   export set_info:= overload(
   [
      proc(the_name::string,$) option overload;
          print(the_name);
      end proc,

      proc(the_name::string,the_age::integer, $) option overload;
          print(the_name);
          print(the_age);
      end proc
   ]);
end module;

person:-set_info("me");
person:-set_info("me",20)

How to make the first example above work? I need to overload a method inside an module with option object that uses _self

update

I found a workaround. But it is not good, but for now. For the overloaded method, instead of using 
           o:-set_info("me");

This works instead

         set_info(o,"me");

So the following now works

o:=Object(person);

#o:-set_info("me");   #do not use with overloaded
#o:-set_info("me",20); #do not use with overloaded

set_info(o,"me");  #now works OK with no error
set_info(o,"me",20); #now works OK with no error

o:-get_name();  #OK since this method  is not overloaded
o:-get_age();  #OK since this method  is not overloaded

I do not understand why _self can't be used with overloaded methods and if this a bug or by design. 

Maple 2023.1 on windows 10

Download self_with_overloaded.mw