Ronan

Nice and simple....

Answered: Ronan 1267

February 23 2024

0 0

@Carl Love I like that.

Its works and doesn't work...

Answered: Ronan 1267

February 16 2024

0 0

@Carl Love I find sometimes it works and sometimes not. About 50-50. I find it useful because it scrolls directly to the response clicked on.

Exactly the effect...

Answered: Ronan 1267

February 15 2024

0 0

@acer That is precisely what I was trying to achieve.

Nice...

Answered: Ronan 1267

February 15 2024

0 0

@rlopez That is good to know. I never think of using the the Student Package.

Dead Slow...

Answered: Ronan 1267

February 14 2024

0 0

Same here. It took minutes after clicking submit to post a simple question this evening.

Thank you. On reflection....

Answered: Ronan 1267

February 14 2024

0 0

@Preben Alsholm I realised about an hour ago, I could get myself into a lot of trouble with altering the default. In a couple of months time when I probably would have forgotten about it.

@acer I see what you mean about foo. I hadn't thought about it before then. Yes it definately gets irrating when someone keeps adding to a specification. Basically there are no extra requirements. There is no point in trying to handle obscure possibilities. I am just trying to catch wrong arguments being passed and the procdeures doing a wrong interpretation. The $ is a very simple way of catching that. Especially if a number is passed.

expects helps too...

Answered: Ronan 1267

February 10 2024

0 0

Is this safe? I wrapped expects around coerce to catch non string entries. Though the error message is rather unwieldy.

>

restart;

>

p := proc(c::expects(coerce(proc(s::string)
                      local L:=StringTools:-LowerCase(s);
                      piecewise(member(L,["blue","b"]),"Blue",
                                member(L,["green","g"]),"Green",
                                member(L,["red","r"]),"Red",
                                ERROR("\"%1\" does not coerce",s))
                    end proc)):="Blue")

  return c;

end proc:

>	p("bLUe"), p("Blue"), p("blue"), p("b"), p("B");

(1)

>	p("ReD"), p("Red"), p("red"), p("r"), p("R");

(2)

>	p("GreEn"), p("Green"), p("green"), p("g"), p("G");

(3)

>

p("God");

Error, (in p) "God" does not coerce

>	p("black");

Error, (in p) "black" does not coerce

>

p();

(4)

>

p(foo);

Error, invalid input: p expects its 1st argument, c, to be coercible via proc (s::string) local L; L := StringTools:-LowerCase(s); piecewise(member(L,["blue", "b"]),"Blue",member(L,["green", "g"]),"Green",member(L,["red", "r"]),"Red",ERROR("\"%1\" does not coerce",s)); end proc, but received foo

>

p(5)

Error, invalid input: p expects its 1st argument, c, to be coercible via proc (s::string) local L; L := StringTools:-LowerCase(s); piecewise(member(L,["blue", "b"]),"Blue",member(L,["green", "g"]),"Green",member(L,["red", "r"]),"Red",ERROR("\"%1\" does not coerce",s)); end proc, but received 5

>

Download 2024-02-10_Q_coercion_ex2-1.mw

I notice the subtly now {...}...

Answered: Ronan 1267

February 10 2024

0 0

@mmcdara Ahh. I use Geomclr:= "...." as the global colour setting but can be changed specifically.

I now notice you put the optional parameters in { }. The makes you have to do clr =... but has the advantage of allowing skipping one if desired. Nice.

Trying an error or incorrect input...

Answered: Ronan 1267

February 10 2024

0 0

@acer

I have experimented with catching an incorrect input. How should I get it to produce an error instead on skipping on. An empty input p() is fine.

restart;

p := proc(c::coerce(proc(s::string)
                      local L:=StringTools:-LowerCase(s);
                      piecewise(member(L,["blue","b"]),"Blue",
                                member(L,["green","g"]),"Green",
                                member(L,["red","r"]),"Red",
                               `not`(menber(L,["blue","b","green","g","red","r"])))
                    end proc):="Blue")

  return c;

end proc:

p("bLUe"), p("Blue"), p("blue"), p("b"), p("B");
             "Blue", "Blue", "Blue", "Blue", "Blue"

p("ReD"), p("Red"), p("red"), p("r"), p("R");
               "Red", "Red", "Red", "Red", "Red"

p("GreEn"), p("Green"), p("green"), p("g"), p("G");
          "Green", "Green", "Green", "Green", "Green"

p("God"),p("black")

 not menber("god", ["blue", "b", "green", "g", "red", "r"]), 

   not menber("black", ["blue", "b", "green", "g", "red", "r"])


p()
                             "Blue"

Nice. Question?...

Answered: Ronan 1267

February 10 2024

0 0

@mmcdara This makes things much neater. I will try setting it up as a procedure that is called inside the package, as this is used in various places. Yes I do need to put in checks for the 0 denominator.

I notice one has to enter
spread2(...clr="Red" , prnt =false)
instead of
spread2(....."Red" , false)

Why is that?

I do like that you skip clr
spread2(p0 , p1, prnt=false)

 Module...
    export spread....,
 Coltest(clr)
local col := substring(StringTools:-Capitalize(clr), 1..1);
           local COL := `if`(col="R", "Red", `if`(col="G", "Green", "Blue"))  
return col
end proc;

spread2:=proc(
               ....
               {clr::string:="Blue"}, 
               {prnt::boolean:=true}
             )
           ....
          Coltest(clr); 
           ....
           if `not`(member(col, {"R", "G", "B"})) then
             error cat("allowed colors are red, green or blue, received ", clr)
           end if:

           if prnt then
             print(cat("Spread 2 [x,y] Points/Vectors wrt origin ",  COL));
           end if:
                 
           if col = "B" then
               return ....

           elif col="G" then
               return ....

           elif col="R" then
               return ....
          end if;
          end proc:

I have it working stably now...

Answered: Ronan 1267

February 08 2024

0 0

@Carl Love Firstly, appologies for the delay in replying. I understand what was happening better now. I evolved my way through things this week.

What works to prevent unintended evaluation in the overload situation has been to use all the inputs for each overload scenario. I kept being caught out by just printing messages withoud using the parameters/arguments,

Have two versions "test" and "test1" where the order of the procedures in the list are completly reversed. Both work nicely and have not hit any unintended eveluations. I have left many of my evolving notes in.

The setup seem to be reliable for invalid inputs too.

>

restart

>	GCb:="Blue"

(1)

>

        test :=overload([

#1;
proc(p0::algebraic,$)
option overload;
[p0];
print("#1 single 1D input. No colour check required");

end,

#2;
proc(p0::algebraic,p1::algebraic,$)
option overload;
[p0,p1];
print("#2 pair of 1D inputs. No colour check required");
end,

#3;
proc(p0::{satisfies(s -> type(s, [algebraic $ 2])),'Vector[row]'(2, algebraic)},
     clr::`string` := GCb,$)
                option overload;
global GCb;
[p0,clr];
if clr="Blue" then
   print("#3 input recognised 2D Point/Vector. Blue.") ;
elif clr= "Red" or clr="Green" then
print("#4 inputs recognised 2D Point/Vector. Red or Green");
end if;
end,

#4 If put before #3 causes false evaluation of #3 type input #4
# [p0,p1,clr] cures the problem because it itse the inputs ;
proc(p0::{satisfies(s -> type(s, [algebraic $ 2])),'Vector[row]'(2, algebraic)},
     p1::{satisfies(s -> type(s, [algebraic $ 2])),'Vector[row]'(2, algebraic)},
     clr::`string` := GCb,$)
                option overload;
global GCb;
[p0,p1,clr];
if clr="Blue" then
   print("#4 inputs recognised pair of 2D Points/Vectors.Valid for Blue.") ;
elif clr= "Red" or clr="Green" then
print("#4 inputs recognised pair of 2D Points/Vectors. Red or Green");
end if;
end,

#4X; If this is moved to before 4 causes false evaluation of #4 type input #4X
# [p0,p1,p2,clr] cures the problem because it itse the inputs;
proc(p0::{satisfies(s -> type(s, [algebraic $ 2])),'Vector[row]'(2, algebraic)},
     p1::{satisfies(s -> type(s, [algebraic $ 2])),'Vector[row]'(2, algebraic)},
     p2::{satisfies(s -> type(s, [algebraic $ 2])),'Vector[row]'(2, algebraic)},
     clr::`string` := GCb,$)
                option overload(callseq_only);
global GCb;
[p0,p1,p2,clr];
if clr="Blue" or clr="Red" or clr="Green" then
   print("#4X inputs recognised Set of 3 2D Points/Vectors.Valid for Blue, Red & Green") ;
end if;
end,

#5;
proc(p0::{satisfies(s -> type(s, [algebraic $ 3])),'Vector[row]'(3, algebraic)},
     clr::`string` := GCb,$)
                option overload;
global GCb;
[p0,clr];
if clr="Blue" then
   print("#5 inputs recognised single 3D Point/Vector");
     else print("#5 error 3D Point/Vector only valid for Blue Geometry");
end if;
end,

#6;
proc(p0::{satisfies(s -> type(s, [algebraic $ 3])), 'Vector[row]'(3, algebraic)},
     p1::{satisfies(s -> type(s, [algebraic $ 3])), 'Vector[row]'(3, algebraic)},
     clr::`string` := GCb,$)
                option overload;
global GCb;
[p0,p1,clr];
if clr="Blue" then
    print("#6 inputs recognised pair of 3D Points/Vectors ") ;
      else print("#6 3D points/vectors only valid for Blue Geometry");
end if;
end,

#7;
proc(p0::{satisfies(s -> type(s, [algebraic $ 2])),'Vector[row]'(2, algebraic)},
     pl::{satisfies(s -> type(s, [algebraic $ 3])),'Vector[column]'(3, algebraic),`+`,procedure},var::satisfies(s -> type(s, [algebraic $ 2])):=[x,y],
     clr::`string` := GCb,$)
        option overload;
[p0,pl,clr];
print("#7 inputs recognised 2D Point and Line valid for Blue, Red & Green") ;
end,
#8;
proc(l1::satisfies(s -> type(s, [algebraic $ 3])),
     l2::[{satisfies(s -> type(s, [algebraic $ 3])), 'Vector[row]'(3, algebraic)}, 'Vector[column]'(3, algebraic)],$)
option overload;
[l1,l2];
print("#8 inputs recognised 3D Point and 3D Line.No colour check Blue only");
end,

#9  if put before #5 it causes false evaluation of #5 type inputs as #9
#    [p0,pl,vars] cure ;
proc(p0::{satisfies(s -> type(s, [algebraic $ 3])),'Vector[row]'(3, algebraic)},
     pl::{'Vector[column]'(4, algebraic), `+`,procedure},var::satisfies(s -> type(s, [algebraic $ 3])):=[x,y,z],$)
        option overload;
global gcb;
[p0,pl,vars];
print("#9 inputs recognised 3D Point and Plane.No colour check Blue only");
end,

#10;
proc(l1::[{satisfies(s -> type(s, [algebraic $ 3])), 'Vector[row]'(3, algebraic)}, 'Vector[column]'(3, algebraic)],
      l2::[{satisfies(s -> type(s, [algebraic $ 3])), 'Vector[row]'(3, algebraic)}, 'Vector[column]'(3, algebraic)],$)
        option overload;
[l1,l2];
print("#10 inputs recognised   Skew lines 3D.No colour check Blue only") ;
end

]):

>

>	# 3d lines a list or row vector for position point and column vector for direction

>	l1:= [<1 \| 5 \| 7>, <3, 7, 9>]; #3D line

[Vector[row](3, {(1) = 1, (2) = 5, (3) = 7}), Vector(3, {(1) = 3, (2) = 7, (3) = 9})]

(2)

>	l2:=[<-4 \| 2 \| 1>, <3, 8, -9>]; #3D line

[Vector[row](3, {(1) = -4, (2) = 2, (3) = 1}), Vector(3, {(1) = 3, (2) = 8, (3) = -9})]

(3)

>

>	l3:= [[1 , 5 , 7], <3, 7, 9>]; #3D line

[[1, 5, 7], Vector(3, {(1) = 3, (2) = 7, (3) = 9})]

(4)

>	l4:=[[-4 , 2, 1 ], <3, 2, -9>]; #3D line

[[-4, 2, 1], Vector(3, {(1) = 3, (2) = 2, (3) = -9})]

(5)

>	# 1 & 2 inputs

>	test(R); test(R,R)

(6)

>	# 3 inputs

>	test([a,b]);

>	test(<a\|b>);

(7)

>	# 4 inputs

>	test([a,b],[e,t]); test([a,b],[e,t],"Green"); test(<a\|b>,<e\|t>,"Red");

>

(8)

>	# 4X inputs

>	test([a,b],[a,c],[d,e])

(9)

>	# 5 inputs

>	test([a,b,c],"Blue"); test([a,b,c]); test([a,b,c],"Red"); test(<a\|b\|c>);

(10)

>

#6 inputs

>	test([a,b,c],[d,e,f]); test([a,b,c],[d,e,f],"Red"); test(<a\|b\|c>,<d\|e\|f>);

(11)

>

#7 inputs

>	test([a,b], <3, 2,d>,"Red");

>	test([a,b], 3x+ 2y+d);

>	test([a,b], 3p+ 2q+d,[p,q]); f:=(p,q)-> 3p+ 2q+d; test([a,b],f(p,q),[p,q])

(12)

>	# 8 inputs

>	test([a,b,c],l1); test([a,b,c],l2); test([a,b,c],l3); test([a,b,c],l4);

(13)

>

#9 inputs

>	test( [s,g,h],<1,2,3,4>); test( [s,g,h],x+2y+3z+4); test( [s,g,h],5r-6s+kt+g,[r,s,t]); h:=(r,s,t)-> 3r+ 2s-7t+6 : # a plane test( [s,g,h],h(r,s,t),[r,s,t])

(14)

>	#10 inputs

>	test(l3,l4); test(l1,l2); test(l1,l3);

(15)

>	#false/incorrect type inputs working correctly as required

>

test()

Error, invalid input: no implementation of test matches the arguments in call, 'test()'

>

>	test([a,b,d],[a,c,f],[d,e,n])

Error, invalid input: no implementation of test matches the arguments in call, 'test([a, b, d],[a, c, f],[d, e, n])'

>	test(1,2,3)

Error, invalid input: no implementation of test matches the arguments in call, 'test(1,2,3)'

>	test([a,b], 3p+ 2q+d,[p,q],[e,t]);

Error, invalid input: no implementation of test matches the arguments in call, 'test([a, b],3*p+2*q+d,[p, q],[e, t])'

>	test( [s,g,h],h(r,s,t),[r,s,t],2)

Error, invalid input: no implementation of test matches the arguments in call, 'test([s, g, h],h(r,s,t),[r, s, t],2)'

>	test( [s,g,h],5r-6s+k*t+g,[r,s,t],"Blue")

Error, invalid input: no implementation of test matches the arguments in call, 'test([s, g, h],k*t+g+5*r-6*s,[r, s, t],"Blue")'

>	test(2,[a,b])

Error, invalid input: no implementation of test matches the arguments in call, 'test(2,[a, b])'

>	test([1,2,3,4,5])

Error, invalid input: no implementation of test matches the arguments in call, 'test([1, 2, 3, 4, 5])'

>	test(5r-6s+k*t+g,[r,s,t],[s,g,h])

Error, invalid input: no implementation of test matches the arguments in call, 'test(k*t+g+5*r-6*s,[r, s, t],[s, g, h])'

>

restart

>	GCb:="Blue"

(16)

>

        test1 :=overload([

#10;
proc(l1::[{satisfies(s -> type(s, [algebraic $ 3])), 'Vector[row]'(3, algebraic)}, 'Vector[column]'(3, algebraic)],
      l2::[{satisfies(s -> type(s, [algebraic $ 3])), 'Vector[row]'(3, algebraic)}, 'Vector[column]'(3, algebraic)],$)
        option overload;
[l1,l2];
print("#10 inputs recognised   Skew lines 3D.No colour check Blue only") ;
end,

#9  if put before #5 it causes false evaluation of #5 type inputs as #9 Is there a way of checking p1 and triger overload or if not presest?
#    [p0,pl,vars] cure ;
proc(p0::{satisfies(s -> type(s, [algebraic $ 3])),'Vector[row]'(3, algebraic)},
     pl::{'Vector[column]'(4, algebraic), `+`,procedure},var::satisfies(s -> type(s, [algebraic $ 3])):=[x,y,z],$)
        option overload;
global gcb;
[p0,pl,vars];
print("#9 inputs recognised 3D Point and Plane.No colour check Blue only");
end,

#8;
proc(l1::satisfies(s -> type(s, [algebraic $ 3])),
     l2::[{satisfies(s -> type(s, [algebraic $ 3])), 'Vector[row]'(3, algebraic)}, 'Vector[column]'(3, algebraic)],$)
option overload;
[l1,l2];
print("#8 inputs recognised 3D Point and 3D Line.No colour check Blue only");
end,
#7;
proc(p0::{satisfies(s -> type(s, [algebraic $ 2])),'Vector[row]'(2, algebraic)},
     pl::{satisfies(s -> type(s, [algebraic $ 3])),'Vector[column]'(3, algebraic),`+`,procedure},var::satisfies(s -> type(s, [algebraic $ 2])):=[x,y],
     clr::`string` := GCb,$)
        option overload;
[p0,pl,clr];
print("#7 inputs recognised 2D Point and Line valid for Blue, Red & Green") ;
end,
#6;
proc(p0::{satisfies(s -> type(s, [algebraic $ 3])), 'Vector[row]'(3, algebraic)},
     p1::{satisfies(s -> type(s, [algebraic $ 3])), 'Vector[row]'(3, algebraic)},
     clr::`string` := GCb,$)
                option overload;
global GCb;
[p0,p1,clr];
if clr="Blue" then
    print("#6 inputs recognised pair of 3D Points/Vectors ") ;
      else print("#6 3D points/vectors only valid for Blue Geometry");
end if;
end,

#5;
proc(p0::{satisfies(s -> type(s, [algebraic $ 3])),'Vector[row]'(3, algebraic)},
     clr::`string` := GCb,$)
                option overload;
global GCb;
[p0,clr];
if clr="Blue" then
   print("#5 inputs recognised single 3D Point/Vector");
     else print("#5 error 3D Point/Vector only valid for Blue Geometry");
end if;
end,

#4X; If this is moved to before 4 causes false evaluation of #4 type input #4X
# [p0,p1,p2,clr] cures the problem because it itse the inputs;
proc(p0::{satisfies(s -> type(s, [algebraic $ 2])),'Vector[row]'(2, algebraic)},
     p1::{satisfies(s -> type(s, [algebraic $ 2])),'Vector[row]'(2, algebraic)},
     p2::{satisfies(s -> type(s, [algebraic $ 2])),'Vector[row]'(2, algebraic)},
     clr::`string` := GCb,$)
                option overload(callseq_only);
global GCb;
[p0,p1,p2,clr];
if clr="Blue" or clr="Red" or clr="Green" then
   print("#4X inputs recognised Set of 3 2D Points/Vectors.Valid for Blue, Red & Green") ;
end if;
end,

#4 If put before #3 causes false evaluation of #3 type input #4
# [p0,p1,clr] cures the problem because it itse the inputs ;
proc(p0::{satisfies(s -> type(s, [algebraic $ 2])),'Vector[row]'(2, algebraic)},
     p1::{satisfies(s -> type(s, [algebraic $ 2])),'Vector[row]'(2, algebraic)},
     clr::`string` := GCb,$)
                option overload;
global GCb;
[p0,p1,clr];
if clr="Blue" then
   print("#4 inputs recognised pair of 2D Points/Vectors.Valid for Blue.") ;
elif clr= "Red" or clr="Green" then
print("#4 inputs recognised pair of 2D Points/Vectors. Red or Green");
end if;
end,

#3;
proc(p0::{satisfies(s -> type(s, [algebraic $ 2])),'Vector[row]'(2, algebraic)},
     clr::`string` := GCb,$)
                option overload;
global GCb;
[p0,clr];
if clr="Blue" then
   print("#3 input recognised 2D Point/Vector. Blue.") ;
elif clr= "Red" or clr="Green" then
print("#4 inputs recognised 2D Point/Vector. Red or Green");
end if;
end,

#2;
proc(p0::algebraic,p1::algebraic,$)
option overload;
[p0,p1];
print("#2 pair of 1D inputs. No colour check required");
end,

#1;
proc(p0::algebraic,$)
option overload;
[p0];
if _params['p0']=NULL then `error nothing entered`
else print("#1 single 1D input. No colour check required");
end if;
end
]):

>

>	# 3d lines a list or row vector for position point and column vector for direction

>	l1:= [<1 \| 5 \| 7>, <3, 7, 9>]; #3D line

[Vector[row](3, {(1) = 1, (2) = 5, (3) = 7}), Vector(3, {(1) = 3, (2) = 7, (3) = 9})]

(17)

>	l2:=[<-4 \| 2 \| 1>, <3, 8, -9>]; #3D line

[Vector[row](3, {(1) = -4, (2) = 2, (3) = 1}), Vector(3, {(1) = 3, (2) = 8, (3) = -9})]

(18)

>

>	l3:= [[1 , 5 , 7], <3, 7, 9>]; #3D line

[[1, 5, 7], Vector(3, {(1) = 3, (2) = 7, (3) = 9})]

(19)

>	l4:=[[-4 , 2, 1 ], <3, 2, -9>]; #3D line

[[-4, 2, 1], Vector(3, {(1) = 3, (2) = 2, (3) = -9})]

(20)

>

>	# 1 & 2 inputs

>	test1(R); test1(R,R)

(21)

>	# 3 inputs

>	test1([a,b]);

>	test1(<a\|b>);

(22)

>	# 4 inputs

>	test1([a,b],[e,t]); test1([a,b],[e,t],"Green"); test1(<a\|b>,<e\|t>,"Red");

(23)

>	# 4X inputs

>	test1([a,b],[a,c],[d,e])

(24)

>	# 5 inputs

>	test1([a,b,c],"Blue"); test1([a,b,c]); test1([a,b,c],"Red"); test1(<a\|b\|c>);

(25)

>

#6 inputs

>	test1([a,b,c],[d,e,f]); test1([a,b,c],[d,e,f],"Red"); test1(<a\|b\|c>,<d\|e\|f>);

(26)

>

#7 inputs

>	test1([a,b], <3, 2,d>,"Red");

>	test1([a,b], 3x+ 2y+d);

>	test1([a,b], 3p+ 2q+d,[p,q]); f:=(p,q)-> 3p+ 2q+d; test1([a,b],f(p,q),[p,q])

(27)

>	# 8 inputs

>	test1([a,b,c],l1); test1([a,b,c],l2); test1([a,b,c],l3); test1([a,b,c],l4);

(28)

>

#9 inputs

>	test1( [s,g,h],<1,2,3,4>); test1( [s,g,h],x+2y+3z+4); test1( [s,g,h],5r-6s+kt+g,[r,s,t]); h:=(r,s,t)-> 3r+ 2s-7t+6 : # a plane test1( [s,g,h],h(r,s,t),[r,s,t])

(29)

>	#10 inputs

>	test1(l3,l4); test1(l1,l2); test1(l1,l3);

(30)

>	#false/incorrect type inputs working correctly as required

>

test1()

Error, invalid input: no implementation of test1 matches the arguments in call, 'test1()'

>

>	test1([a,b,d],[a,c,f],[d,e,n])

Error, invalid input: no implementation of test1 matches the arguments in call, 'test1([a, b, d],[a, c, f],[d, e, n])'

>	test(1,2,3)

(31)

>	test1([a,b], 3p+ 2q+d,[p,q],[e,t]);

Error, invalid input: no implementation of test1 matches the arguments in call, 'test1([a, b],3*p+2*q+d,[p, q],[e, t])'

>	test1( [s,g,h],h(r,s,t),[r,s,t],2)

Error, invalid input: no implementation of test1 matches the arguments in call, 'test1([s, g, h],h(r,s,t),[r, s, t],2)'

>	test1( [s,g,h],5r-6s+k*t+g,[r,s,t],"Blue")

Error, invalid input: no implementation of test1 matches the arguments in call, 'test1([s, g, h],k*t+g+5*r-6*s,[r, s, t],"Blue")'

>	test1(2,[a,b])

Error, invalid input: no implementation of test1 matches the arguments in call, 'test1(2,[a, b])'

>	test1([1,2,3,4,5])

Error, invalid input: no implementation of test1 matches the arguments in call, 'test1([1, 2, 3, 4, 5])'

>	test1(5r-6s+k*t+g,[r,s,t],[s,g,h])

Error, invalid input: no implementation of test1 matches the arguments in call, 'test1(k*t+g+5*r-6*s,[r, s, t],[s, g, h])'

>

Download Q_2024-02-08_Proc_types_in_list_inputs.mw

I need to improve my understanding....

Answered: Ronan 1267

February 03 2024

0 0

@Preben Alsholm Thank you. So this is a case of my "understanding" being an assumption. i.e. I always thought if the proc input had parameters that did not have default values one had to enter them all or an error would occur. Not so then if a particular one or more is not used, it can be ommitted. Of course that would be the last ones in the inputs.That is a very interesting subtle point..

restart;
foo1:=overload([                        
                  proc(P1::list,P2::list,P3::list,P4::list,$) # 4 list inputs
                     option overload;
                     print("3 lists");
                  end proc,

                  proc(P1::list,P2::list,a::algebraic:=4,$)
                     option overload;
                     print("2 lists");
                  end proc
                       ]):
foo1([1,2],[3,4]); #Output correct because P1 and P2 are lists P3 and P4 ommited
foo1([1,2],[3,4],4); 
foo1([1,2],[3,4],[4,7]);

Yes Puzzling, A possible work around...

Answered: Ronan 1267

February 03 2024

0 0

@Preben Alsholm Yes. My undarstanding was that if the inputs do not satisfy the input criteria of a procedure the next procedure is checked. There apperas to be more to it than that.

I suppose a work around would be to repeat the inputs blandly for each proc in the list to force usage.

 {[
proc(P1... P3  )
option...
[P1,P2,P3]
.....
end proc,

proc(P1::type.. ,P2::type...,a::type...:=4)
option.....
[P1,P2,a]
......

end proc
])

and

There is a subltety I am missing here....

Answered: Ronan 1267

February 03 2024

0 0

@Preben Alsholm Thank you. There is still something I don't quiet understand yet. I see if I didn't specifically use P3 in 1st proc , I get the inorrect output. I know that would mean redundant input whic is not good.

foo2:=overload([                   
                  proc(P1::list,P2::list,P3::list,$)
                      option overload(callseq_only);
                   return  [P1,P2,P3],"3lists";
                  end proc,
                  proc(P1::list,P2::list,a::algebraic:=4,$)
                      option overload;
                     
                   return  [P1,P2],"2 lists"
                  end proc
                       ]):
foo2([1,2],[3,4]); 
foo2([1,2],[3,4],5);
foo2([1,2],[3,4],[4,7]);
                  [[1, 2], [3, 4]], "2 lists"

                  [[1, 2], [3, 4]], "2 lists"

               [[1, 2], [3, 4], [4, 7]], "3lists"

foo3:=overload([                   
                  proc(P1::list,P2::list,P3::list,$)
                      option overload(callseq_only);
                     #2*P3; # using this line it all work correctly;
                   return  "3lists";
                  end proc,
                  proc(P1::list,P2::list,a::algebraic:=4,$)
                      option overload;
                     
                   return  "2 lists"
                  end proc
                       ]):
foo3([1,2],[3,4]); #incorrect output;
foo3([1,2],[3,4],5);
foo3([1,2],[3,4],[4,7]);
                            "3lists"

E-Mail Address:
Password:
Remember Me:	Automatically sign in on future visits

E-Mail Address:
Password:
Remember Me:	Automatically sign in on future visits

Ask a Question

Create a Post

1267 Reputation

14 Badges

MaplePrimes Activity

These are replies submitted by Ronan

Nice and simple....

Its works and doesn't work...

Exactly the effect...

Nice...

Dead Slow...

Thank you. On reflection....

I understand...

expects helps too...

I notice the subtly now {...}...

Trying an error or incorrect input...

Nice. Question?...

I have it working stably now...

I need to improve my understanding....

Yes Puzzling, A possible work around...

There is a subltety I am missing here....

Save this setting as your default sorting preference?

Ask a Question

Create a Post

Generating PDF…

Save this setting as your default sorting preference?
Note: You can change your preference any time in your account settings
Don't show this again