[MUG] Nargs

[MUG] Re: Nargs
Author: Maple User Group    Posted: Fri, 20 Dec 2002 14:18:17 -0500
>> From: Maple User Group /> -=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=- Date: Tue, 17 Dec 2002 15:33:32 -0500 (EST) From: Carl Devore /> To: /> Subject: Nargs On Mon, 16 Dec 2002, PierLuigi Zezza wrote: > I am constructing (Maple >= 5 release 5) a procedure which has a function > (procedure) as an input and I want to detect the number of arguments of the > input. Correction: You want to detect the number of parameters, not the number of arguments. Procedures are defined with parameters and called with arguments. Counting the arguments is trivial. > I tried with > > myproc:=proc(f::procedure) nops({op(1,eval(f))}) end; > > but I would like to have has input also linear combinations or composition > of functions as > > g:=x->(x+1); > > (2*f-g)(x); > > h:=t->(t^2,t); > > (f@h)(t); > but my procedure does not work and I think that the reason is that > > type(2*f-g,procedure); > false Yes, that is the reason. I cannot come up with a simple type expression that will cover all the cases. Maybe someone else can. Nonetheless, I think that the following will cover the vast majority of cases, certainly all your cases above. Nparams:= proc(f) local F,1,x; F:= indets(f, `@`); if F<>{} then return Nparams(op(-1, F[1])) fi; F:= indets(f, procedure); F1:= remove(x-> member(_syslib, {attributes(x)}, F); if F1<>{} then nops([op(1, eval(F1[1]))]) elif F<>{} then nops([op(1, eval(F[1]))]) else 0 fi end proc; Since many Maple procedures like arctan and abs are weird cases with mulitple parameters, I restrict the count, if possible, to the user-defined procedures. But my procedure might still give unexpected results for something like /> -=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=- From: "Dr Francis J. Wright" /> To: /> Subject: Nargs Date: Wed, 18 Dec 2002 17:37:20 -0000 Generalize the type test to accept expressions of whatever form you want. If the procedure is called with an argument that is not explicitly of type procedure then analyse the expression to find its procedural components and check their argument numbers: with a composition you presumably care only about the rightmost procedure; with a sum or product you presumably want the minimum number of arguments, etc. You might also want to think about how to handle a purely symbolic function, i.e. a symbol to which no procedure has been assigned, which you might want to trap as an error. Francis -=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=- Date: Wed, 18 Dec 2002 21:21:25 -0500 (EST) From: Stephen Forrest /> To: /> Subject: Nargs Right. Your procedure will have to check the type of the arguments, and handle these cases differently. In the case of the composition @, it's obviously the number of arguments of the innermost procedure you want, so recurse onto that. In the case of a sum or product of procedures, it's probably the maximum of all numbers of arguments of each of the subprocedures that you want. However, for whatever expression you invent, it will probably be possible to come up with a counterexample of something acts like a procedure but isn't handled properly. And you will never be able to handle cases that manipulate args and nargs directly in the procedure body, like p := proc() if nargs>1 then args[2] elsif nargs>0 args[1] else 0 fi; end: except as very special cases. So I'm afraid don't really understand why you'd like to do this. Steve -=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=-=*=- From: "Greg Gamble" /> To: /> Subject: Nargs Date: Thu, 19 Dec 2002 12:21:28 +0800 There are two things to consider here: * the *actual* number of arguments that a function is *called* with, (this is dynamically assigned to the variable `nargs' when a function/ procedure is executed); * the number of *named arguments* the function is *defined* with (for want of a better name let's call this the Arity of a function, since functions may be unary = 1-ary, binary = 2-ary, ternary = 3-ary or, in general, n-ary) Suppose we define f as follows: > f := (x, y) -> (x, x^2, x^3); 2 3 f := (x, y) -> (x, x , x ) > f(1, 2); 1, 1, 1 > f(1); 1, 1, 1 > f(1, 2, 3); 1, 1, 1 As you can see, despite the fact that f was defined with 2 arguments (so its Arity is 2), Maple is happy to execute f with any number of arguments, so long as it can evaluate it. Here y is not needed in the body of the function, so Maple does not object to f being called with 1 argument. By not checking the number of arguments, Maple allows for the possibility of a variable number of arguments or optional arguments. Let's define g to be functionally equivalent to f via proc so that we can report via `nargs' the number of arguments its called with: > g := proc(x, y) printf("nargs: %a\n", nargs); (x, x^2, x^3); end; g := proc(x, y) printf("nargs: %a\n", nargs); x, x^2, x^3 end proc > g(1, 2); nargs: 2 1, 1, 1 > g(1); nargs: 1 1, 1, 1 > g(1, 2, 3); nargs: 3 1, 1, 1 Now consider: > h := proc(x) > local y; > if nargs > 1 then > y := args[2]; > fi; > (x, x^2, x^3); > end; h := proc(x) local y; if 1 < nargs then y := args[2] end if; x, x^2, x^3 end proc Again, h is equivalent to f but the (useless) y is an *optional argument* that is local to the body of the function, i.e. by my definition y is not a *named argument*: the Arity of h is 1, whereas the Arity of f or g is 2. This makes the concept of Arity a bit nebulous in Maple. You were hoping that Maple would somehow reduce linear combinations and compositions to an arrow operator form which Maple doesn't do, so eval(f@h) is just f@h, and there are other considerations e.g. Maple treats constants as functions: 3(x, y, z) is 3. Your myproc is a rudimentary Arity but you do not want to enforce the type `procedure' on its argument (as you discovered). Here's maybe something close to what you want: > Arity := f -> > if type(f, constant) then > 0 > elif type(f, procedure) then > nops({op(1, eval(f))}) > elif type(f, `@`) then > Arity(op(2, f)) > elif type(f, {`+`, `*`}) then > max(seq(Arity(i), i = [op(f)])) > else > error "arity unknown for this function type" > fi; Arity := proc(f) option operator, arrow; if type(f, constant) then 0 elif type(f, procedure) then nops({op(1, eval(f))}) elif type(f, `@`) then Arity(op(2, f)) elif type(f, {`*`, `+`}) then max(seq(Arity(i), i = [op(f)])) else error "arity unknown for this function type" end if end proc Features of (the above) Arity: 1. Arity(f + g) = max(Arity(f), Arity(g)) 2. Arity(f * g) = max(Arity(f), Arity(g)) 3. Arity(f@g) = Arity(g) My guess is that you actually want to test well-defined-ness as well i.e. you want: 1. Arity(f + g) = Arity(f) if Arity(f) = Arity(g) 2. Arity(f * g) = Arity(g) if 0 <> Arity(f) or Arity(f) = Arity(g) 3. Arity(f@g) = Arity(g) if Arity(f) = ArityOfInverse(g) where ArityOfInverse is defined by: > ArityOfInverse := f -> nops([f(x['i'] $ 'i' = 1 .. Arity(f))]); ArityOfInverse := f -> nops([f(x['i'] $ ('i' = 1 .. Arity(f)))]) Anyway, I hope those ideas are helpful. Regards, Greg Gamble // Greg Gamble, Dept. of Maths & Stats // // Curtin University, Bentley WA 6102 // // Mailto: // // WWW: http://www.maths.curtin.edu.au/~gregg //

Previous by date: [MUG] dsolve does not find second solution, Helmut Kahovec
Next by date: [MUG] how to implicitplot this func, Ruan Zhichao
Previous thread: [MUG] Evaluation problem, Colin Campbell - IST
Next thread: [MUG] how to implicitplot this func, Ruan Zhichao