The procedure is to plot text points and lines. so it has three procedures in it. the 1st and 2nd work to plot text and pooints. But the 2nd is blocking access to the 3rd to plot lines. If I swap the 2nd and 3rd the problem reverse. I use typ and tyl to try to focre points or lines. What other check could if use  here?

Download Q_2024-08-29_Plot_in_RT.mw

I use a procedure called Isee  to print to screen procedures from my packages.

However if the procedure is overloaded it Isee doesn't print it. Is there a way around this.
I have inserted screen shots to show the outputs for the package.

Download 2024-08-12_print_overloaded_procedure.mw

The overloaded  procedure here test returns based on 2 lists or 3 lists entered. The two list has a mixed input type with a default value. The default value of "a" can cause a problem if an explicit value in not entered for "a" in foo1. I not sure is the mixed input type is adding to the problem.
By changing the order of the procedures the problem is avoidable here. But this just a simple example. When there are 6 or so procedures it can be very difficult to select a correct ordering.

Is there a way around this, apart from don't have default values?

I could experiment with changing the input order in each proc but that would break up some logical input sequences on me.

Download 2024-02-3_Q_Overload_proc_.mw

I have this overloaded function foo(). 

restart;

foo:= overload(  
        [
        proc(A::integer,$)option overload;
            print("first one, _passed = ", _passed," _npassed = ",_npassed);             
        end proc,

        proc(A::integer,B::integer,$)option overload;
            print("second one  _passed = ", _passed," _npassed = ",_npassed);
        end proc
       ]);

Which works OK. so I can now do 

foo(1)
foo(1,2)

But I wanted to indicate that the proc returns say ::integer , and this where I am stuck, I do not know where to add this ::integer

With non-overloaded proc's, this is the syntax

foo:=proc(A::integer,$)::integer;
     ......
end proc;

but I can't do this with the overloaded function. If I type

foo:= overload(  
        [
        proc(A::integer,$)option overload;
            print("first one, _passed = ", _passed," _npassed = ",_npassed);             
        end proc,

        proc(A::integer,B::integer,$)option overload;
            print("second one  _passed = ", _passed," _npassed = ",_npassed);
        end proc
       ])::integer;

Maple simply does not like it. typing foo(1) now it just echos the definition back.

And these give syntax errors

foo:= overload(  
        [
        proc(A::integer,$)::integer option overload;
            print("first one, _passed = ", _passed," _npassed = ",_npassed);    
        end proc,

        proc(A::integer,B::integer,$)::integer option overload;
            print("second one  _passed = ", _passed," _npassed = ",_npassed);
        end proc
       ]);

Tried many other variations and looked at help but see nothing to far.

Can one add ::type to indicate type proc returns with overloaded proc?

Maple 2023.2.1

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

 About 6 years ago I aked  a question on testing types in a package. How to Test Input Typed to a Procedure to Determine what to do? - MaplePrimes.  @Carl Love supplied the very good code below. I never used the answer back then as I really didn't understand what to do with it. I have a somewhat of a better idea now and I really need to be able to use this in general..

 Basically the code checks that all the inputs are of the same type and order (which is what the original question specified).

 Q1:- I now need to check  a mixed input type

         A:: a 2 list , B a 3 list   

          or 

           A:: a 2 Vector, and B a 3 Vector.

         etc

       I tried modifying the ModuleApply part of the code at the end, but that either causes errors or kernal looses connection.

Q2:-  What is a good way to handle different numbers of inputs to procedures (exported) here eg Proc1(a), Proc2(a,b), ....,                   ProcN(a1,...,aN)

Q3:-    Would the package exports of the module be the procedures inside the Mydispatch? Or does all of MyModule sit inside                the  package module?

  I have three different packages I would like to apply this to in general.

Download Q_19-11-22_Module_Test_Types.mw

I have some of my main functions defined to take input in different formats. Some have required  parameters and also optional parameters. Similar to how say dsolve can take one ode, or a list of ode's or set of ode's and also other additional arguments.

Currently I use something like  ode::{`=`,set(`=`),list(`=`)} in the signature of the proc to indicate this input can be any of these types. There are also optional aguments.

So inside the proc, it does lots and lots of if this then do such else do such type of logic in order to determine which case/combination of input it is called with.

I am thinking of rewriting all of the API to use overload. Yes, it means I will have lots of copies of the same proc, each to handle specific case of the signature. But it also mean it will be now much simpler inside each of the overloaded proc's to determine which case of call it is processing.

I'd like to ask, is there anything to be aware of before making this change? does it affect performance much? It seems to me it will make the logic and the program simpler.  Here is a very simple example to illustrate.

Which you think is better? I like the overload version more. But I am worried that I will end up with too many versions of the API since I need one for each possible combination and may be this will slow Maple down? 

The following is the worksheet also.

Download overload.mw

How does one undo an overload?                                                                        

The suggested solution in the answer https://mapleprimes.com/questions/234325-Use-Of-self--Inside-Object-Constructor  worked OK in the setup shown in that question.

But it does not work when putting the constructor inside overload

Here is an example where it works (i.e. by removing the type from _self as suggested in the above answer)

restart;

person:=module()
    option object;
    local name::string:="";

    #notice no _self::person, just _self
    export ModuleCopy::static:= proc( _self, proto::person, the_name::string, $ )            
           name:= the_name;
    end proc;

end module;


p:=Object(person,"me")

The above works. But since I have different constructors, once I put the above inside overload, using the same exact syntax, now the error comes back

restart;

person:=module()
    option object;
    local name::string:="";

    export ModuleCopy::static:= overload( 
    [
       proc( _self, proto::person, the_name::string, $ ) option overload;           
           name:= the_name;
      end proc
    ]);

end module;
             

p:=Object(person,"me")

Error, static procedure `ModuleCopy` refers to non-static local or export `name::string` in surrounding scope

I did not expect that using overload will cause any change to how it behaves. Is this a bug?

Below is worksheet also.

Download OO_version.mw

It would seem that if a package is loaded at the "top-level" via with() and the worksheet also has a procedure definition which contains a 'uses' statement for the same package (OK, admittedly a bit redundant), the commands from the relevant package actually "go missing".

See the output from test4() in the attached.

I can't believe that this is deliberate, because when trying to 'compartmentalise' code, then a 'uses' statement in a procedure seems like a good idea. To have this fail because the "top-level" worksheet contains a with() statement loading the same package seems perverse.

Please don't post workarounds - I already know several ways to do achieve it. I'm trying to find out if this behaviour is "deliberate" or a "bug". If the latter, it has been around for a long time because I have checked all the way back to Maple 18: every version exhibits the same behaviour

Download usewith.mw

I was wondering if there was any way to reassign the "||" operator to calculate parallel resistors?

like this:

R1 || R2 = (1/R1+1/R2)^(-1)

Hi,

I have some matrix valued functions that that I can only define piecewise. Unfortunately I have some problems to manipulate those functions. Piecewise sees to do the job for  scalar valued functions. There I can easily differentiale and add results. For Matrix valued functions however, those features seem to not be availible.
 

I can work around these limitations by manually applying all operations to the operands of the piecewise function. Like I show here:

Download Scratch.mw

I think my workaround is very cumbersome and error prone. Is there a better way to tackle this probem? Or should I try to overload all needed operations, and is this even possible?

Thanks for all suggestions!

Honigmelone

Hello,

I have two simple module's:

1) ------------------------------------------------------------------------

Point := proc(xx::float,yy::float)
    return module()
        local x := xx,y := yy;
        export ShowPoint,GetX,GetY;
        
        ShowPoint := proc()
            printf("Point X,Y -> [%f,%f]",x,y);
        end proc;

        GetX := proc()
            return x;
        end proc;        
        GetY := proc()
            return y;
        end proc;    
    end module:
end proc:

2) ------------------------------------------------------------------------

PointMath := module()
    option package;  
    export `+`;
    
    `+` := proc(a::Point(float,float),b::Point(float,float))
        option overload;
        Point(a:-GetX()+b:-GetX(),a:-GetY()+b:-GetY());
    end proc;
end module:

------------------------------------------------------------------------

Next I use first module:

p1:=Point(1.2,1.4);

p2:=Point(1.0,2.0);

Finally I want to add above two points:

with(PointMath)

p2:=p1+p2

The results is:

p2:=p1+p2

Why is not called operator '+' and two points are not added?

Best,

Rariusz

I have run into a "funny" feature of 2-D input: It seems to convert something like k/2 into this k*`^`(2,-1). While this would often not be an issue (it is correct after all), it becomes a problem when used in an argument list to a procedure. It becomes even more of a problem when, by chance, I have overloaded `^` to act on specific types that I have defined.

Let me try to explain briefly. I have a package called "Lattice" that does whatever it does (not of relevance here). I am writing a little manual for this package, for which I use 2-D input so I can write it in Maple and have the examples right in it and "live".

Here is what happens:

with(Lattice) # load the package

QFh:=Quad(0,kf/2) # Define an element for Lattice

Error, invalid input: Lattice:-`^` expects its 1st argument, element, to be of type Element, but received 2

Copy-pasting kf/2 into a 1-d worksheet, I get

QFh := Quad(0, kf*Lattice[`^`](2, -1));

So it uses Lattice[`^`] which actually appears to bypass the overload I have in the Lattice package. `^` is defined like this in Lattice:

`^`:=proc(element::Element,n::algebraic) option overload; # Element is a defined type in Lattice
...
end proc;

How can I possibly rewrite `^` to fall-back to Maple's ^ operator when called as Lattice[`^`] ?? I know there is a function overload() but have no experience with it. Would it even help?

Or am I missing something completely here? I do not use 2-D input for my usual work, but in this case I want and need to use it. The reason for its bizarre rewrite of "/2" is beyond me. Note that I can replace /2 by *0.5; but that causes problems later on for algebraic work as 1/2 is not 0.5 in Maple. I tried *1/2 but that has the same problem.

Has anyone a clean solution for this? I assume this effect is not limited to my own package but would affect others as well.

M.D.

PS: I ran into this using Maple 15 but I doubt it is specific to this particular version.

MatrixOperation := module() option package;  export `+`, LinearAlgebra;
    `+` := proc(a::float, b::float) option overload;
 :-`+`(map(x->x^2,a),map(x->x^2,b));
    end proc;
end module;

with(MatrixOperation);
with(LinearAlgebra):
m := Matrix([[1,2],[3,4]]);
L := MatrixMatrixMultiply(m,m);

1 2  1 2
3 4  3 4

1*1+2*3 = 1 + 6 = 1 after overload + with a+b-a*b
1*2+2*4 = 2 + 8 = -6

L should be Matrix([[1, -6],[....]])