From: Pankaj S. <pan...@gm...> - 2015-02-17 14:35:28
|
Let I have some method/function, f(x):=x^2; I want to know that which lisp method in source code facilitates this feature. I am finding it problematic to find because there is no method name used that I can refer to which helps in function definition. -- Regards, Pankaj Sejwal |
From: Stavros M. (Σ. Μ. <mac...@al...> - 2015-02-17 15:16:48
|
To see the internal representation of an expression, use ?print: ?print('(f(x):=x)) I quoted the expression, because I don't want to see the result of the evaluation, but the expression itself. This gives ((mdefine simp) (($f) $x) $x) So the main operator is mdefine. Let's see if this is defined as a Lisp function: :lisp (symbol-function 'mdefine) => error No, so now let's look at its property list: :lisp (symbol-plist 'mdefine) ...somewhere in the middle of that, there's: MFEXPR* #<FUNCTION (LAMBDA # :I "/Applications/Maxima/maxima-5.34.1/src/mlisp.lisp") {1000BC88CB}> This says that it's defined as an anonymous function in the file mlisp.lisp. Go to that file, and there is a definition (defmspec mdefine (l) ...) defmspec is the way to define Maxima functions that don't evaluate their arguments, which of course mdefine can't. -s On Tue, Feb 17, 2015 at 9:34 AM, Pankaj Sejwal <pan...@gm...> wrote: > Let I have some method/function, > > f(x):=x^2; > > I want to know that which lisp method in source code facilitates this > feature. I am finding it problematic to find because there is no method > name used that I can refer to which helps in function definition. > > > -- > > Regards, > Pankaj Sejwal > > > ------------------------------------------------------------------------------ > Download BIRT iHub F-Type - The Free Enterprise-Grade BIRT Server > from Actuate! Instantly Supercharge Your Business Reports and Dashboards > with Interactivity, Sharing, Native Excel Exports, App Integration & more > Get technology previously reserved for billion-dollar corporations, FREE > > http://pubads.g.doubleclick.net/gampad/clk?id=190641631&iu=/4140/ostg.clktrk > _______________________________________________ > Maxima-discuss mailing list > Max...@li... > https://lists.sourceforge.net/lists/listinfo/maxima-discuss > > |
From: Stavros M. (Σ. Μ. <mac...@al...> - 2015-02-17 16:34:47
|
By the way, what exactly are you trying to find out? The code for mdefine is mostly book-keeping, so won't help you understand how functions work in Maxima. Are you interested in understanding the semantics of *applying* a function? (see meval, mapply, and maybe simplifya) What are some examples of cases that you find interesting/difficult/puzzling? Are you interested in questions of *scope*? -- Maxima essentially has one flat global space for functions, except that you can use 'local' to dynamically (not statically) override a definition. -s On Tue, Feb 17, 2015 at 10:16 AM, Stavros Macrakis (Σταῦρος Μακράκης) < mac...@al...> wrote: > To see the internal representation of an expression, use ?print: > > ?print('(f(x):=x)) > > I quoted the expression, because I don't want to see the result of the > evaluation, but the expression itself. This gives > > ((mdefine simp) (($f) $x) $x) > > So the main operator is mdefine. > > Let's see if this is defined as a Lisp function: > > :lisp (symbol-function 'mdefine) > => error > > No, so now let's look at its property list: > > :lisp (symbol-plist 'mdefine) > > ...somewhere in the middle of that, there's: > > MFEXPR* #<FUNCTION (LAMBDA # :I > "/Applications/Maxima/maxima-5.34.1/src/mlisp.lisp") {1000BC88CB}> > > This says that it's defined as an anonymous function in the file > mlisp.lisp. > > Go to that file, and there is a definition > > (defmspec mdefine (l) ...) > > defmspec is the way to define Maxima functions that don't evaluate their > arguments, which of course mdefine can't. > > -s > > On Tue, Feb 17, 2015 at 9:34 AM, Pankaj Sejwal <pan...@gm...> > wrote: > >> Let I have some method/function, >> >> f(x):=x^2; >> >> I want to know that which lisp method in source code facilitates this >> feature. I am finding it problematic to find because there is no method >> name used that I can refer to which helps in function definition. >> >> >> -- >> >> Regards, >> Pankaj Sejwal >> >> >> ------------------------------------------------------------------------------ >> Download BIRT iHub F-Type - The Free Enterprise-Grade BIRT Server >> from Actuate! Instantly Supercharge Your Business Reports and Dashboards >> with Interactivity, Sharing, Native Excel Exports, App Integration & more >> Get technology previously reserved for billion-dollar corporations, FREE >> >> http://pubads.g.doubleclick.net/gampad/clk?id=190641631&iu=/4140/ostg.clktrk >> _______________________________________________ >> Maxima-discuss mailing list >> Max...@li... >> https://lists.sourceforge.net/lists/listinfo/maxima-discuss >> >> > |
From: Pankaj S. <pan...@gm...> - 2015-02-18 13:37:18
|
Thanks for telling me way to find the needed function, it was very un-obvious to me and its the correct method as needed. I am trying to figure out how contexts work on maxima and also tried to make it better because what it does is not very helpful and also not documented properly. Going forward I want to see how one could implement packages so that all doesn't sit in global space. Presently all variables,symbols,functions,rules sit in global space(as you have also referred) but its better to be contained in one specified package and there should be interaction possible amongst the packages. So, its important to see where functions get recognized by maxima and where it all goes finally. As far as contexts are concerned, I have tried the following things and find them working fine, lets create a few contexts, newcontext(d1); declare(d1,complex); assume(a>b); newcontext(d1); declare(d2,integer); newcontext(d1); declare(d3,complex); assume(b>a); /*conflicting with assumption of d1 */ a) I don't see any command to switch among contexts, though there is activate/deactivate but it doesn't bring one to a specified context. ;;;------------------------------------------------- ;;; This function switches from present context to the context ;;; specified as argument passed to the function. (defmfun $switchcontext(x) (cond ((not (symbolp x)) (nc-err '$newcontext x)) ((member x $contexts :test #'eq) (putprop x '($global) 'subc) (setq context x $context x)) (t (mtell (intl:gettext "switchcontext: context ~M doesn't exists in ~M.") x $contexts ) nil))) ;;;------------------------------------------------- context; => d3 facts(); => [kind(d3,complex),b>a] switchcontext(d1); => d1 facts(); => [kind(d1,complex),a>b] b) List of nonactive contexts, ;;;------------------------------------------------- (defmfun $nonactivecontexts() (cons '(mlist) (let ((temp (cdr $contexts))) (loop for item in $activecontexts do (setf temp (remove item temp)))temp))) ;;;------------------------------------------------- let I have activated d2, then nonactivecontexts(); => [d3,d1,c4,initial,global] c) facts() always returns data from present contexts and cannot tell anything about other contexts(also specified in documentation) unless activated, if, activecontexts; => [d1,d2] facts(d1,d2); => [kind(d1,complex),a>b] /*no facts from d2*/ To address this issue, ;--------------------------------------------------- (defmfun $factsl (&rest ctxt ) (cons '(mlist) (let ((temp nil)(ctxt (cons '(mlist) ctxt))) (cond ((listp ctxt)(loop for s in (cdr ctxt) do (push ($facts s) temp))) ) temp))) ;;;------------------------------------------------- factsl(d1,d2); =>[[kind(d2,integer)],[kind(d1,complex),a>b]] Also its possible to get facts from activated contexts while being present in any context, not necessarily d1 or d2. d) In case one also wants to list facts from contexts that are not active, one could use, ;;;------------------------------------------------- ;;; Generates facts for all contexts passed as argument to function ;;; irrespective of they are active or not. (defmfun $factsall (&rest contxt) (cons '(mlist) (nreverse (let ((final nil)(temp nil)(ctxt (cons '(mlist) contxt)) (activecontxt (cdr $activecontexts))(nonactive (cdr ($nonactivecontexts)))) (cond ((listp ctxt) (loop for s in (cdr ctxt) do (progn (if (member s (cdr $contexts)) (if (member s nonactive) (progn ($activate s)(push ($facts s) final)($deactivate s)) (push ($facts s) final))))) (apply #'$activate activecontxt))) final)))) ;;;------------------------------------------------- activecontexts; => [d1,d2] nonactivecontexts(); => [d3,initial,global] factsl(d1,d3); => [[],[kind(d1,complex),a>b]] but factsall(d1,d3); => (%o104) [[kind(d1,complex),a>b],[kind(d3,complex),b>a]] context; => initial; e) There is "supcontext" but I don't quite understand what it does because switching to it, facts from subcontext become invisible. Also it makes more sense to create subcontexts from existing contexts. ;;;------------------------------------------------- ;;; It combines the facts of contexts passed as arguments,sort of subcontext of all given contexts ;;; Maintains unique entries ;;; Doesn't added the entry that conflicts with existing one ;;; combinecontexts(name_of_context,ctxt1,ctxt2...ctxtn) (defmfun $combinecontexts(&rest ctxts) (let ((newct (car ctxts)) (ctxt (cdr ctxts)) (temp nil)) (cond ((every #'(lambda(it)(find it $contexts)) ctxt) (setf temp (apply #'$factsall ctxt)) ($flatten temp)($newcontext newct) (restore-facts (cdr ($flatten temp)))) (t (merror (intl:gettext "combinecontexts: context ~M doesn't exists.") (cons '(mlist)(ldiff ctxt $contexts))))) newct)) ;;;------------------------------------------------- context; => initial activecontexts; => [] combinecontexts(w4,d1,d3); => w4 facts(); => [kind(d1,complex),a>b,kind(d3,complex)] /* comflicting a<b not added*/ It would be great if this sort of functionality could be extended to contain all functions,rules,assumptions, declarations etc. Machinery needed to do it all is already there, I have just used them for my purpose. On Tue, Feb 17, 2015 at 8:34 AM, Stavros Macrakis (Σταῦρος Μακράκης) < mac...@al...> wrote: > By the way, what exactly are you trying to find out? > > The code for mdefine is mostly book-keeping, so won't help you understand > how functions work in Maxima. > > Are you interested in understanding the semantics of *applying* a > function? (see meval, mapply, and maybe simplifya) What are some examples > of cases that you find interesting/difficult/puzzling? > > Are you interested in questions of *scope*? -- Maxima essentially has one > flat global space for functions, except that you can use 'local' to > dynamically (not statically) override a definition. > > -s > > On Tue, Feb 17, 2015 at 10:16 AM, Stavros Macrakis (Σταῦρος Μακράκης) < > mac...@al...> wrote: > >> To see the internal representation of an expression, use ?print: >> >> ?print('(f(x):=x)) >> >> I quoted the expression, because I don't want to see the result of the >> evaluation, but the expression itself. This gives >> >> ((mdefine simp) (($f) $x) $x) >> >> So the main operator is mdefine. >> >> Let's see if this is defined as a Lisp function: >> >> :lisp (symbol-function 'mdefine) >> => error >> >> No, so now let's look at its property list: >> >> :lisp (symbol-plist 'mdefine) >> >> ...somewhere in the middle of that, there's: >> >> MFEXPR* #<FUNCTION (LAMBDA # :I >> "/Applications/Maxima/maxima-5.34.1/src/mlisp.lisp") {1000BC88CB}> >> >> This says that it's defined as an anonymous function in the file >> mlisp.lisp. >> >> Go to that file, and there is a definition >> >> (defmspec mdefine (l) ...) >> >> defmspec is the way to define Maxima functions that don't evaluate their >> arguments, which of course mdefine can't. >> >> -s >> >> On Tue, Feb 17, 2015 at 9:34 AM, Pankaj Sejwal <pan...@gm...> >> wrote: >> >>> Let I have some method/function, >>> >>> f(x):=x^2; >>> >>> I want to know that which lisp method in source code facilitates this >>> feature. I am finding it problematic to find because there is no method >>> name used that I can refer to which helps in function definition. >>> >>> >>> -- >>> >>> Regards, >>> Pankaj Sejwal >>> >>> >>> ------------------------------------------------------------------------------ >>> Download BIRT iHub F-Type - The Free Enterprise-Grade BIRT Server >>> from Actuate! Instantly Supercharge Your Business Reports and Dashboards >>> with Interactivity, Sharing, Native Excel Exports, App Integration & more >>> Get technology previously reserved for billion-dollar corporations, FREE >>> >>> http://pubads.g.doubleclick.net/gampad/clk?id=190641631&iu=/4140/ostg.clktrk >>> _______________________________________________ >>> Maxima-discuss mailing list >>> Max...@li... >>> https://lists.sourceforge.net/lists/listinfo/maxima-discuss >>> >>> >> > -- Regards, Pankaj Sejwal ____________________________________________________ "The more I read, the more I acquire, the more certain I am that I know nothing.” - Voltaire |
From: Stavros M. (Σ. Μ. <mac...@al...> - 2015-02-18 23:58:51
|
Let's focus on assume contexts for now -- which is what most of your mail is about (though you mention packages etc.). To switch contexts, just bind the variable "context". This is documented under ? context [assume(q>0), block([context:'c1], assume(a>b), facts()), block([context:'c2], assume(a<b), facts()), facts()]; [[q > 0], [a > b], [b > a], [q > 0]] I agree that the context functions and their terminology are confusing, what with activation, supcontexts (which I think are better called subcontexts), etc. A first useful step would be to document the existing functionality clearly. Re your function combinecontexts, I don't understand why it is meaningful or useful to ignore inconsistent relations. Consider using the context mechanism to simplify IF statements. For example: if a<0 then abs(a) could simplify to -a because abs(a) can be simplified in a context where a<0. Now consider something like if a<0 then (if a>0 then abs(a)) Should that really simplify to -a? -s On Wed, Feb 18, 2015 at 8:36 AM, Pankaj Sejwal <pan...@gm...> wrote: > Thanks for telling me way to find the needed function, it was very > un-obvious to me and its the correct method as needed. > > I am trying to figure out how contexts work on maxima and also tried to > make it better because what it does is not very helpful and also not > documented properly. > > Going forward I want to see how one could implement packages so that all > doesn't sit in global space. Presently all > variables,symbols,functions,rules sit in global space(as you have also > referred) but its better to be contained in one specified package and there > should be interaction possible amongst the packages. > So, its important to see where functions get recognized by maxima and > where it all goes finally. > > As far as contexts are concerned, I have tried the following things and > find them working fine, > lets create a few contexts, > > newcontext(d1); > declare(d1,complex); > assume(a>b); > newcontext(d1); > declare(d2,integer); > newcontext(d1); > declare(d3,complex); > assume(b>a); /*conflicting with assumption of d1 */ > > a) I don't see any command to switch among contexts, though there is > activate/deactivate but it doesn't bring one to a specified context. > ;;;------------------------------------------------- > ;;; This function switches from present context to the context > ;;; specified as argument passed to the function. > > (defmfun $switchcontext(x) > (cond ((not (symbolp x)) (nc-err '$newcontext x)) > ((member x $contexts :test #'eq) > (putprop x '($global) 'subc) > (setq context x $context x)) > (t (mtell (intl:gettext "switchcontext: context ~M doesn't exists in > ~M.") x $contexts ) nil))) > ;;;------------------------------------------------- > context; => d3 > facts(); => [kind(d3,complex),b>a] > switchcontext(d1); => d1 > facts(); => [kind(d1,complex),a>b] > > > b) List of nonactive contexts, > ;;;------------------------------------------------- > (defmfun $nonactivecontexts() > (cons '(mlist) (let ((temp (cdr $contexts))) > (loop for item in $activecontexts do > (setf temp (remove item temp)))temp))) > ;;;------------------------------------------------- > let I have activated d2, then > nonactivecontexts(); => [d3,d1,c4,initial,global] > > > c) facts() always returns data from present contexts and cannot tell > anything about other contexts(also specified in documentation) unless > activated, > if, > activecontexts; => [d1,d2] > facts(d1,d2); => [kind(d1,complex),a>b] /*no facts from d2*/ > To address this issue, > ;--------------------------------------------------- > (defmfun $factsl (&rest ctxt ) > (cons '(mlist) (let ((temp nil)(ctxt (cons '(mlist) ctxt))) > (cond ((listp ctxt)(loop for s in (cdr ctxt) do (push > ($facts s) temp))) ) > temp))) > > ;;;------------------------------------------------- > factsl(d1,d2); =>[[kind(d2,integer)],[kind(d1,complex),a>b]] > Also its possible to get facts from activated contexts while being present > in any context, not necessarily d1 or d2. > > d) In case one also wants to list facts from contexts that are not active, > one could use, > ;;;------------------------------------------------- > ;;; Generates facts for all contexts passed as argument to function > ;;; irrespective of they are active or not. > (defmfun $factsall (&rest contxt) > (cons '(mlist) (nreverse (let ((final nil)(temp nil)(ctxt (cons '(mlist) > contxt)) > (activecontxt (cdr $activecontexts))(nonactive > (cdr ($nonactivecontexts)))) > (cond ((listp ctxt) > (loop for s in (cdr ctxt) do > (progn > (if (member s (cdr $contexts)) > (if (member s nonactive) > (progn ($activate s)(push > ($facts s) final)($deactivate s)) > (push ($facts s) final))))) > (apply #'$activate activecontxt))) > final)))) > ;;;------------------------------------------------- > activecontexts; => [d1,d2] > nonactivecontexts(); => [d3,initial,global] > factsl(d1,d3); => [[],[kind(d1,complex),a>b]] but > factsall(d1,d3); => (%o104) [[kind(d1,complex),a>b],[kind(d3,complex),b>a]] > context; => initial; > > e) There is "supcontext" but I don't quite understand what it does because > switching to it, facts from subcontext become invisible. Also it makes more > sense to create subcontexts from existing contexts. > > ;;;------------------------------------------------- > ;;; It combines the facts of contexts passed as arguments,sort of > subcontext of all given contexts > ;;; Maintains unique entries > ;;; Doesn't added the entry that conflicts with existing one > ;;; combinecontexts(name_of_context,ctxt1,ctxt2...ctxtn) > > (defmfun $combinecontexts(&rest ctxts) > (let ((newct (car ctxts)) (ctxt (cdr ctxts)) (temp nil)) > (cond ((every #'(lambda(it)(find it $contexts)) ctxt) > (setf temp (apply #'$factsall ctxt)) ($flatten > temp)($newcontext newct) > (restore-facts (cdr ($flatten temp)))) > (t (merror (intl:gettext "combinecontexts: context ~M doesn't > exists.") (cons '(mlist)(ldiff ctxt $contexts))))) > newct)) > ;;;------------------------------------------------- > context; => initial > activecontexts; => [] > combinecontexts(w4,d1,d3); => w4 > facts(); => [kind(d1,complex),a>b,kind(d3,complex)] /* comflicting a<b not > added*/ > > It would be great if this sort of functionality could be extended to > contain all functions,rules,assumptions, declarations etc. > Machinery needed to do it all is already there, I have just used them for > my purpose. > > > > > > > > On Tue, Feb 17, 2015 at 8:34 AM, Stavros Macrakis (Σταῦρος Μακράκης) < > mac...@al...> wrote: > >> By the way, what exactly are you trying to find out? >> >> The code for mdefine is mostly book-keeping, so won't help you understand >> how functions work in Maxima. >> >> Are you interested in understanding the semantics of *applying* a >> function? (see meval, mapply, and maybe simplifya) What are some examples >> of cases that you find interesting/difficult/puzzling? >> >> Are you interested in questions of *scope*? -- Maxima essentially has >> one flat global space for functions, except that you can use 'local' to >> dynamically (not statically) override a definition. >> >> -s >> >> On Tue, Feb 17, 2015 at 10:16 AM, Stavros Macrakis (Σταῦρος Μακράκης) < >> mac...@al...> wrote: >> >>> To see the internal representation of an expression, use ?print: >>> >>> ?print('(f(x):=x)) >>> >>> I quoted the expression, because I don't want to see the result of the >>> evaluation, but the expression itself. This gives >>> >>> ((mdefine simp) (($f) $x) $x) >>> >>> So the main operator is mdefine. >>> >>> Let's see if this is defined as a Lisp function: >>> >>> :lisp (symbol-function 'mdefine) >>> => error >>> >>> No, so now let's look at its property list: >>> >>> :lisp (symbol-plist 'mdefine) >>> >>> ...somewhere in the middle of that, there's: >>> >>> MFEXPR* #<FUNCTION (LAMBDA # :I >>> "/Applications/Maxima/maxima-5.34.1/src/mlisp.lisp") {1000BC88CB}> >>> >>> This says that it's defined as an anonymous function in the file >>> mlisp.lisp. >>> >>> Go to that file, and there is a definition >>> >>> (defmspec mdefine (l) ...) >>> >>> defmspec is the way to define Maxima functions that don't evaluate their >>> arguments, which of course mdefine can't. >>> >>> -s >>> >>> On Tue, Feb 17, 2015 at 9:34 AM, Pankaj Sejwal <pan...@gm...> >>> wrote: >>> >>>> Let I have some method/function, >>>> >>>> f(x):=x^2; >>>> >>>> I want to know that which lisp method in source code facilitates this >>>> feature. I am finding it problematic to find because there is no method >>>> name used that I can refer to which helps in function definition. >>>> >>>> >>>> -- >>>> >>>> Regards, >>>> Pankaj Sejwal >>>> >>>> >>>> ------------------------------------------------------------------------------ >>>> Download BIRT iHub F-Type - The Free Enterprise-Grade BIRT Server >>>> from Actuate! Instantly Supercharge Your Business Reports and Dashboards >>>> with Interactivity, Sharing, Native Excel Exports, App Integration & >>>> more >>>> Get technology previously reserved for billion-dollar corporations, FREE >>>> >>>> http://pubads.g.doubleclick.net/gampad/clk?id=190641631&iu=/4140/ostg.clktrk >>>> _______________________________________________ >>>> Maxima-discuss mailing list >>>> Max...@li... >>>> https://lists.sourceforge.net/lists/listinfo/maxima-discuss >>>> >>>> >>> >> > > > -- > Regards, > Pankaj Sejwal > ____________________________________________________ > "The more I read, the more I acquire, the more certain I am that I know > nothing.” - Voltaire > |
From: Stavros M. (Σ. Μ. <mac...@al...> - 2015-02-19 03:08:57
|
My example is bogus, but you get the idea.... On Wed, Feb 18, 2015 at 6:58 PM, Stavros Macrakis (Σταῦρος Μακράκης) < mac...@al...> wrote: > Let's focus on assume contexts for now -- which is what most of your mail > is about (though you mention packages etc.). > > To switch contexts, just bind the variable "context". This is documented > under ? context > > [assume(q>0), block([context:'c1], assume(a>b), facts()), > block([context:'c2], assume(a<b), facts()), facts()]; > [[q > 0], [a > b], [b > a], [q > 0]] > > I agree that the context functions and their terminology are confusing, > what with activation, supcontexts (which I think are better called > subcontexts), etc. A first useful step would be to document the existing > functionality clearly. > > Re your function combinecontexts, I don't understand why it is meaningful > or useful to ignore inconsistent relations. Consider using the context > mechanism to simplify IF statements. For example: > > if a<0 then abs(a) > > could simplify to -a because abs(a) can be simplified in a context where > a<0. Now consider something like > > if a<0 then (if a>0 then abs(a)) > > Should that really simplify to -a? > > -s > > On Wed, Feb 18, 2015 at 8:36 AM, Pankaj Sejwal <pan...@gm...> > wrote: > >> Thanks for telling me way to find the needed function, it was very >> un-obvious to me and its the correct method as needed. >> >> I am trying to figure out how contexts work on maxima and also tried to >> make it better because what it does is not very helpful and also not >> documented properly. >> >> Going forward I want to see how one could implement packages so that all >> doesn't sit in global space. Presently all >> variables,symbols,functions,rules sit in global space(as you have also >> referred) but its better to be contained in one specified package and there >> should be interaction possible amongst the packages. >> So, its important to see where functions get recognized by maxima and >> where it all goes finally. >> >> As far as contexts are concerned, I have tried the following things and >> find them working fine, >> lets create a few contexts, >> >> newcontext(d1); >> declare(d1,complex); >> assume(a>b); >> newcontext(d1); >> declare(d2,integer); >> newcontext(d1); >> declare(d3,complex); >> assume(b>a); /*conflicting with assumption of d1 */ >> >> a) I don't see any command to switch among contexts, though there is >> activate/deactivate but it doesn't bring one to a specified context. >> ;;;------------------------------------------------- >> ;;; This function switches from present context to the context >> ;;; specified as argument passed to the function. >> >> (defmfun $switchcontext(x) >> (cond ((not (symbolp x)) (nc-err '$newcontext x)) >> ((member x $contexts :test #'eq) >> (putprop x '($global) 'subc) >> (setq context x $context x)) >> (t (mtell (intl:gettext "switchcontext: context ~M doesn't exists in >> ~M.") x $contexts ) nil))) >> ;;;------------------------------------------------- >> context; => d3 >> facts(); => [kind(d3,complex),b>a] >> switchcontext(d1); => d1 >> facts(); => [kind(d1,complex),a>b] >> >> >> b) List of nonactive contexts, >> ;;;------------------------------------------------- >> (defmfun $nonactivecontexts() >> (cons '(mlist) (let ((temp (cdr $contexts))) >> (loop for item in $activecontexts do >> (setf temp (remove item temp)))temp))) >> ;;;------------------------------------------------- >> let I have activated d2, then >> nonactivecontexts(); => [d3,d1,c4,initial,global] >> >> >> c) facts() always returns data from present contexts and cannot tell >> anything about other contexts(also specified in documentation) unless >> activated, >> if, >> activecontexts; => [d1,d2] >> facts(d1,d2); => [kind(d1,complex),a>b] /*no facts from d2*/ >> To address this issue, >> ;--------------------------------------------------- >> (defmfun $factsl (&rest ctxt ) >> (cons '(mlist) (let ((temp nil)(ctxt (cons '(mlist) ctxt))) >> (cond ((listp ctxt)(loop for s in (cdr ctxt) do (push >> ($facts s) temp))) ) >> temp))) >> >> ;;;------------------------------------------------- >> factsl(d1,d2); =>[[kind(d2,integer)],[kind(d1,complex),a>b]] >> Also its possible to get facts from activated contexts while being >> present in any context, not necessarily d1 or d2. >> >> d) In case one also wants to list facts from contexts that are not >> active, one could use, >> ;;;------------------------------------------------- >> ;;; Generates facts for all contexts passed as argument to function >> ;;; irrespective of they are active or not. >> (defmfun $factsall (&rest contxt) >> (cons '(mlist) (nreverse (let ((final nil)(temp nil)(ctxt (cons >> '(mlist) contxt)) >> (activecontxt (cdr $activecontexts))(nonactive >> (cdr ($nonactivecontexts)))) >> (cond ((listp ctxt) >> (loop for s in (cdr ctxt) do >> (progn >> (if (member s (cdr $contexts)) >> (if (member s nonactive) >> (progn ($activate s)(push >> ($facts s) final)($deactivate s)) >> (push ($facts s) final))))) >> (apply #'$activate >> activecontxt))) final)))) >> ;;;------------------------------------------------- >> activecontexts; => [d1,d2] >> nonactivecontexts(); => [d3,initial,global] >> factsl(d1,d3); => [[],[kind(d1,complex),a>b]] but >> factsall(d1,d3); => (%o104) >> [[kind(d1,complex),a>b],[kind(d3,complex),b>a]] >> context; => initial; >> >> e) There is "supcontext" but I don't quite understand what it does >> because switching to it, facts from subcontext become invisible. Also it >> makes more sense to create subcontexts from existing contexts. >> >> ;;;------------------------------------------------- >> ;;; It combines the facts of contexts passed as arguments,sort of >> subcontext of all given contexts >> ;;; Maintains unique entries >> ;;; Doesn't added the entry that conflicts with existing one >> ;;; combinecontexts(name_of_context,ctxt1,ctxt2...ctxtn) >> >> (defmfun $combinecontexts(&rest ctxts) >> (let ((newct (car ctxts)) (ctxt (cdr ctxts)) (temp nil)) >> (cond ((every #'(lambda(it)(find it $contexts)) ctxt) >> (setf temp (apply #'$factsall ctxt)) ($flatten >> temp)($newcontext newct) >> (restore-facts (cdr ($flatten temp)))) >> (t (merror (intl:gettext "combinecontexts: context ~M doesn't >> exists.") (cons '(mlist)(ldiff ctxt $contexts))))) >> newct)) >> ;;;------------------------------------------------- >> context; => initial >> activecontexts; => [] >> combinecontexts(w4,d1,d3); => w4 >> facts(); => [kind(d1,complex),a>b,kind(d3,complex)] /* comflicting a<b >> not added*/ >> >> It would be great if this sort of functionality could be extended to >> contain all functions,rules,assumptions, declarations etc. >> Machinery needed to do it all is already there, I have just used them for >> my purpose. >> >> >> >> >> >> >> >> On Tue, Feb 17, 2015 at 8:34 AM, Stavros Macrakis (Σταῦρος Μακράκης) < >> mac...@al...> wrote: >> >>> By the way, what exactly are you trying to find out? >>> >>> The code for mdefine is mostly book-keeping, so won't help you >>> understand how functions work in Maxima. >>> >>> Are you interested in understanding the semantics of *applying* a >>> function? (see meval, mapply, and maybe simplifya) What are some examples >>> of cases that you find interesting/difficult/puzzling? >>> >>> Are you interested in questions of *scope*? -- Maxima essentially has >>> one flat global space for functions, except that you can use 'local' to >>> dynamically (not statically) override a definition. >>> >>> -s >>> >>> On Tue, Feb 17, 2015 at 10:16 AM, Stavros Macrakis (Σταῦρος Μακράκης) < >>> mac...@al...> wrote: >>> >>>> To see the internal representation of an expression, use ?print: >>>> >>>> ?print('(f(x):=x)) >>>> >>>> I quoted the expression, because I don't want to see the result of the >>>> evaluation, but the expression itself. This gives >>>> >>>> ((mdefine simp) (($f) $x) $x) >>>> >>>> So the main operator is mdefine. >>>> >>>> Let's see if this is defined as a Lisp function: >>>> >>>> :lisp (symbol-function 'mdefine) >>>> => error >>>> >>>> No, so now let's look at its property list: >>>> >>>> :lisp (symbol-plist 'mdefine) >>>> >>>> ...somewhere in the middle of that, there's: >>>> >>>> MFEXPR* #<FUNCTION (LAMBDA # :I >>>> "/Applications/Maxima/maxima-5.34.1/src/mlisp.lisp") {1000BC88CB}> >>>> >>>> This says that it's defined as an anonymous function in the file >>>> mlisp.lisp. >>>> >>>> Go to that file, and there is a definition >>>> >>>> (defmspec mdefine (l) ...) >>>> >>>> defmspec is the way to define Maxima functions that don't evaluate >>>> their arguments, which of course mdefine can't. >>>> >>>> -s >>>> >>>> On Tue, Feb 17, 2015 at 9:34 AM, Pankaj Sejwal <pan...@gm...> >>>> wrote: >>>> >>>>> Let I have some method/function, >>>>> >>>>> f(x):=x^2; >>>>> >>>>> I want to know that which lisp method in source code facilitates this >>>>> feature. I am finding it problematic to find because there is no method >>>>> name used that I can refer to which helps in function definition. >>>>> >>>>> >>>>> -- >>>>> >>>>> Regards, >>>>> Pankaj Sejwal >>>>> >>>>> >>>>> ------------------------------------------------------------------------------ >>>>> Download BIRT iHub F-Type - The Free Enterprise-Grade BIRT Server >>>>> from Actuate! Instantly Supercharge Your Business Reports and >>>>> Dashboards >>>>> with Interactivity, Sharing, Native Excel Exports, App Integration & >>>>> more >>>>> Get technology previously reserved for billion-dollar corporations, >>>>> FREE >>>>> >>>>> http://pubads.g.doubleclick.net/gampad/clk?id=190641631&iu=/4140/ostg.clktrk >>>>> _______________________________________________ >>>>> Maxima-discuss mailing list >>>>> Max...@li... >>>>> https://lists.sourceforge.net/lists/listinfo/maxima-discuss >>>>> >>>>> >>>> >>> >> >> >> -- >> Regards, >> Pankaj Sejwal >> ____________________________________________________ >> "The more I read, the more I acquire, the more certain I am that I know >> nothing.” - Voltaire >> > > |
From: Pankaj S. <pan...@gm...> - 2015-02-19 04:08:55
|
On Thu, Feb 19, 2015 at 5:28 AM, Stavros Macrakis (Σταῦρος Μακράκης) < mac...@al...> wrote: > Let's focus on assume contexts for now -- which is what most of your mail > is about (though you mention packages etc.). > > To switch contexts, just bind the variable "context". This is documented > under ? context > > [assume(q>0), block([context:'c1], assume(a>b), facts()), > block([context:'c2], assume(a<b), facts()), facts()]; > [[q > 0], [a > b], [b > a], [q > 0]] > I always thought contexts as something more special than plain variables because I thought it will require reloading facts and may be it is handled in some different way. > > I agree that the context functions and their terminology are confusing, > what with activation, supcontexts (which I think are better called > subcontexts), etc. A first useful step would be to document the existing > functionality clearly. > I agree, without examples functionalities remain largely mysterious. > > Re your function combinecontexts, I don't understand why it is meaningful > or useful to ignore inconsistent relations. Consider using the context > mechanism to simplify IF statements. For example: > > if a<0 then abs(a) > > could simplify to -a because abs(a) can be simplified in a context where > a<0. Now consider something like > > if a<0 then (if a>0 then abs(a)) > > Should that really simplify to -a? > command "combinecontexts" actually combines the facts from different specified contexts to generate a new context with facts combined from those specified. If its combincontexts(w4,d1,d2) then it means return a new context w4 with facts from d1 & d2. It is not possible to have conflicting contexts within one contexts, hence it doesn't add it. I have used a built in maxima lisp function "restore-facts" that does the work of loading the facts supplied as list in some context and it doesn't included inconsistent fact. -- Regards, Pankaj Sejwal |
From: Stavros M. (Σ. Μ. <mac...@al...> - 2015-02-19 17:18:40
|
Inline: On Wed, Feb 18, 2015 at 11:08 PM, Pankaj Sejwal <pan...@gm...> wrote: > > On Thu, Feb 19, 2015 at 5:28 AM, Stavros Macrakis (Σταῦρος Μακράκης) < > mac...@al...> wrote: > >> Let's focus on assume contexts for now -- which is what most of your mail >> is about (though you mention packages etc.). >> >> To switch contexts, just bind the variable "context". This is documented >> under ? context >> >> [assume(q>0), block([context:'c1], assume(a>b), facts()), >> block([context:'c2], assume(a<b), facts()), facts()]; >> [[q > 0], [a > b], [b > a], [q > 0]] >> > > I always thought contexts as something more special than plain > > variables because I thought it will require reloading facts and may be it > is handled in some different way. > c1 and c2 are just the *names* of the contexts. I agree that the context functions and their terminology are confusing, >> what with activation, supcontexts (which I think are better called >> subcontexts), etc. A first useful step would be to document the existing >> functionality clearly. >> > > I agree, without examples functionalities remain largely mysterious. > > Why don't you write some tests and organize the results? > >> Re your function combinecontexts, I don't understand why it is meaningful >> or useful to ignore inconsistent relations. Consider using the context >> mechanism to simplify IF statements. For example: >> >> if a<0 then abs(a) >> >> could simplify to -a because abs(a) can be simplified in a context where >> a<0. Now consider something like >> >> if a<0 then (if a>0 then abs(a)) >> >> >> Should that really simplify to -a? >> > > command "combinecontexts" actually combines the facts from different > specified contexts to generate a new context with facts combined from those > specified. > If its combincontexts(w4,d1,d2) then it means return a new context w4 with > facts from d1 & d2. > > It is not possible to have conflicting contexts within one contexts, hence > it doesn't add it. > I have used a built in maxima lisp function "restore-facts" that does the > work of loading t > > he facts supplied as list in some context and it doesn't included > inconsistent fact. > I understand that ignoring conflicting facts is easy to implement. That doesn't mean that it's useful or meaningful. By the way, the current behavior of 'activate' has a similar problem. If two activated contexts conflict, it seems to chose one of them (independently of the order in which they were activated) to prevail: block([context:'c1], assume(a>0))$ block([context:'c2], assume(a<0))$ map(lambda([cs], apply('activate,cs), [[activecontexts, map(facts,cs), sign(a)],apply('deactivate,cs)][1] ), '[[],[c1],[c2],[c1,c2],[c2,c1]]); [ [[], [], pnz], [[c1], [[a > 0]], pos], [[c2], [[0 > a]], [[c2, c1], [[a > 0], [0 > a]], neg], [[c1, c2], [[0 > a], [a > 0]], neg] ] -s |
From: Pankaj S. <pan...@gm...> - 2015-02-20 04:44:29
|
On Thu, Feb 19, 2015 at 10:48 PM, Stavros Macrakis (Σταῦρος Μακράκης) < mac...@al...> wrote: > Inline: > > On Wed, Feb 18, 2015 at 11:08 PM, Pankaj Sejwal <pan...@gm...> > wrote: > >> >> On Thu, Feb 19, 2015 at 5:28 AM, Stavros Macrakis (Σταῦρος Μακράκης) < >> mac...@al...> wrote: >> >>> Let's focus on assume contexts for now -- which is what most of your >>> mail is about (though you mention packages etc.). >>> >>> To switch contexts, just bind the variable "context". This is documented >>> under ? context >>> >>> [assume(q>0), block([context:'c1], assume(a>b), facts()), >>> block([context:'c2], assume(a<b), facts()), facts()]; >>> [[q > 0], [a > b], [b > a], [q > 0]] >>> >> >> I always thought contexts as something more special than plain >> >> variables because I thought it will require reloading facts and may be >> it is handled in some different way. >> > > c1 and c2 are just the *names* of the contexts. > > I agree that the context functions and their terminology are confusing, >>> what with activation, supcontexts (which I think are better called >>> subcontexts), etc. A first useful step would be to document the existing >>> functionality clearly. >>> >> >> I agree, without examples functionalities remain largely mysterious. >> >> > > Why don't you write some tests and organize the results? > > >> >>> Re your function combinecontexts, I don't understand why it is >>> meaningful or useful to ignore inconsistent relations. Consider using the >>> context mechanism to simplify IF statements. For example: >>> >>> if a<0 then abs(a) >>> >>> could simplify to -a because abs(a) can be simplified in a context where >>> a<0. Now consider something like >>> >>> if a<0 then (if a>0 then abs(a)) >>> >>> >>> Should that really simplify to -a? >>> >> > >> command "combinecontexts" actually combines the facts from different >> specified contexts to generate a new context with facts combined from those >> specified. >> If its combincontexts(w4,d1,d2) then it means return a new context w4 >> with facts from d1 & d2. >> >> It is not possible to have conflicting contexts within one contexts, >> hence it doesn't add it. >> I have used a built in maxima lisp function "restore-facts" that does the >> work of loading t >> >> he facts supplied as list in some context and it doesn't included >> inconsistent fact. >> > > I understand that ignoring conflicting facts is easy to implement. That > doesn't mean that it's useful or meaningful. > > > I think I will not be able to agree on this because a set of facts in one context must be non-conflicting. If a>0 is a fact then if(a>0) then (if(a<0) then abs(a))) should do nothing for a<=0. Once a fact has been presumed, it should be there without any exception. If you have a sound use case, it could help me understand more. > > By the way, the current behavior of 'activate' has a similar problem. If > two activated contexts conflict, it seems to chose one of them > (independently of the order in which they were activated) to prevail: > > block([context:'c1], assume(a>0))$ > block([context:'c2], assume(a<0))$ > > map(lambda([cs], > apply('activate,cs), > [[activecontexts, map(facts,cs), > sign(a)],apply('deactivate,cs)][1] > ), > '[[],[c1],[c2],[c1,c2],[c2,c1]]); > > [ > [[], [], pnz], > [[c1], [[a > 0]], pos], > [[c2], [[0 > a]], > [[c2, c1], [[a > 0], [0 > a]], neg], > [[c1, c2], [[0 > a], [a > 0]], neg] > ] > > > Well I wasn't even aware of it and looks like you have introduced all of us to a new bug. -- Regards, Pankaj Sejwal |