You can subscribe to this list here.
2009 
_{Jan}
(2) 
_{Feb}
(5) 
_{Mar}

_{Apr}

_{May}
(2) 
_{Jun}
(8) 
_{Jul}
(4) 
_{Aug}

_{Sep}

_{Oct}
(2) 
_{Nov}
(6) 
_{Dec}


2010 
_{Jan}
(1) 
_{Feb}
(1) 
_{Mar}
(3) 
_{Apr}
(2) 
_{May}
(2) 
_{Jun}
(2) 
_{Jul}
(18) 
_{Aug}
(13) 
_{Sep}
(7) 
_{Oct}

_{Nov}

_{Dec}
(2) 
2011 
_{Jan}

_{Feb}
(11) 
_{Mar}

_{Apr}
(4) 
_{May}

_{Jun}
(1) 
_{Jul}
(18) 
_{Aug}
(16) 
_{Sep}
(12) 
_{Oct}
(12) 
_{Nov}
(19) 
_{Dec}
(42) 
2012 
_{Jan}
(16) 
_{Feb}
(3) 
_{Mar}
(8) 
_{Apr}
(14) 
_{May}
(30) 
_{Jun}
(5) 
_{Jul}
(7) 
_{Aug}
(3) 
_{Sep}
(10) 
_{Oct}
(4) 
_{Nov}
(10) 
_{Dec}
(1) 
2013 
_{Jan}
(14) 
_{Feb}
(8) 
_{Mar}
(5) 
_{Apr}
(3) 
_{May}
(9) 
_{Jun}
(19) 
_{Jul}

_{Aug}
(27) 
_{Sep}
(5) 
_{Oct}
(18) 
_{Nov}
(12) 
_{Dec}
(8) 
2014 
_{Jan}
(5) 
_{Feb}
(8) 
_{Mar}
(20) 
_{Apr}
(22) 
_{May}
(28) 
_{Jun}
(9) 
_{Jul}
(6) 
_{Aug}
(46) 
_{Sep}
(40) 
_{Oct}
(15) 
_{Nov}
(8) 
_{Dec}
(34) 
2015 
_{Jan}
(20) 
_{Feb}
(15) 
_{Mar}
(18) 
_{Apr}
(20) 
_{May}
(3) 
_{Jun}
(13) 
_{Jul}
(10) 
_{Aug}
(19) 
_{Sep}
(8) 
_{Oct}
(31) 
_{Nov}
(26) 
_{Dec}
(13) 
2016 
_{Jan}
(13) 
_{Feb}
(4) 
_{Mar}
(14) 
_{Apr}
(28) 
_{May}
(19) 
_{Jun}
(7) 
_{Jul}
(1) 
_{Aug}

_{Sep}
(19) 
_{Oct}
(4) 
_{Nov}

_{Dec}

S  M  T  W  T  F  S 






1

2

3

4

5

6

7

8

9

10

11

12

13

14
(5) 
15
(3) 
16
(3) 
17
(1) 
18

19

20

21

22

23

24

25

26

27

28

29

30

From: Rainer Schöpf <rainer.schoepf@gm...>  20131117 13:08:10

On Sun, 20 Oct 2013 at 15:40 +0100, Arthur Norman wrote: > This is posted here so that "many eyes" can see problems and issues before > I go and implement something... > > At present autoload capability for Reduce packages all goes in > support/entry.red. This is rather bad for modularity, and it results in > only a rather odd selection of things being set up to autoload. I think it > would be nicer if direction re autoload stubs was put where the relevant > entrypoints get defined. In addition, algebraic mode packages cannot be autoloaded at any point in a calculation; attempting to do so causes surprising effects. specfn is such a package. > There are two things that need to be established  an autoload stub itself > and properties like 'stat and 'simpfn that direct the parser and > simplifier. > > Perhaps when a function is being defined the build process will know how > many arguments it takes and what package it is within, so MAYBE it will be > possible to have new syntax > symbolic autoload procedure blahstat(arg1, arg2, ...); > ...; > and maybe the same prefix can be used for some uses of PUT (etc) as in > autoload put('blah, 'stat, 'blahstat); I'm not sure about this. Establishing the 'stat property changes REDUCE's syntax, ie. REDUCE behaves differently depending on whether the package is loaded. It seems to me that we want that syntax definition to be present in the REDUCE core and only load the code if necessary. > > Now if "autoload" as a keyword does not clash with other things then that > sounds OK and it would be such that it led to the generation of exactly > the same code as present locally, but the though is that when one of those > statements is parsed it transcribes information into a central place that > amounts to an autoload database. Hmmm simple ways of doing that would > tend to make it harder for future moves to allow parallel (re)building of > Reduce packages  so anybody who believes that that will ever be possible > and is about to work on it needs to speak up to prevent this being a > blockage! Otherwise in a sequential build model this would be the build > process reading a file of entrypoints at the start, updating it and > writing it back when the package has been remade. > > There is then a potential mess about getting this information into the > main Reduce image. > Several ideas come to mind at present. > (a) put the entrpoints in a fasl module (that gets remade alongside > remaking any other package) and having the "begin" function load it as > Reduce starts up. This slows down building and slows down startup  I do > not know how much by. > (b) Since the autoload stubs are small and all can reasonably be > interpreted just read the entrypoint database as a Lisp file and use > a readevalprint loop to instantiate things inside "begin". Hmmm again > slows down startup and the issue of knowing where to find the file is > potentially ugly. > (c) When a Reduce image is created get that process to inspect the > entrypoint database and wire the information from there into the image. > Startup is then rapid but any packages compiled after the preseved image > is made risk not having their entrypoints included  perhaps until a > second time things are built. So this maybe involves an extra step to be > done certainly at the end of a full recompile to rebuild the main image > including the latest set of entrypoints... People who like to update just > fractions of Reduce incrementally instead of doing a full rebuild might > find this not to their taste? I'd go with (a) or (b). > I am at present inclined to believe that having an "entrypoint" qualifier > in source code ought to make it much easier to get autoload a bit more > pervasive. That in turn ought to reduce the use of "load_package" in > source files (again there is an issue of how up to date the entrypoint > information is in the Reduce image used to build things...) and might be > good. Agreed. I'm all for the autoload keyword; even if it remains a noop for the time being, it shows which functions are package entrypoints and makes it much easier to spot errors in the autoload setup. The various calls to load_package are a bit of a mess. Look at, e.g., defint/defintx which contains: load_package solve,misc; as well as if not getd 'solvesq then load_package solve; With a "proper" autoload setup, all these load_package calls shouldn't be necessary. (As an aside, solve and friends are already documented in the manual, so there is no reason to not include them in the core.) > So I suspect I want something like (b) put not in "begin" but in the code > used to recompile a package, so that whenever you recompile a package you > have the latest and best set of entrypoints active. And then something > like (c) for the benefit of general users. > > A change that would be made with extensive use of this is that > simplification rules and syntax established by a package would tend to be > active ALWAYS, and not only once somebody had explicitly loaded the > package. The thoughts here arose because I recently made the "declare" > keyword in the assert package autoload assert  and a consquence is that > that makes "declare" a known word for everybody all the time. Such chages > can force us to address conflicts between packages and consider names > carefully so that not too many users are inconveniences when suddenly > function and variable names that they have used end up having > systemspecified meaning... Again, agreed. I find this much better than the current state where loading a package might expectedly change the way one of your identifiers is parsed or evaluated. Obviously, this will still happen from time to time  some additional packages are too special to have their syntax chagnes included into the core. So, I propose to add a (yet to be defined) list of packages to the core in the sense that their syntax is included and documented. This means that identifiers like "limit" or "gamma" will be predefined and therefore reserved. Rainer 
From: Rainer Schöpf <rainer.schoepf@gm...>  20131116 06:58:42

On Fri, 15 Nov 2013 at 19:17 0500, Bard Ermentrout wrote: > Is there any way to differentiate under the integral sign. I'd like to > define a function: > int(exp(a*cos(x)),x,0,pi); > and then get a Taylor series approximation of it in terms of a. > > Reduce does not understand how to differentiate under the integra sign to > get a bunch of simple integrals of powers of cos(x) Differentiation under the integral sign depends on the switch allowdfint which is off by default. See section 7.4.1 of the manual for a description of switches influencing differentiation. Rainer 
From: Rainer Schöpf <rainer.schoepf@gm...>  20131116 06:55:02

Hello, are you still looking at the old svn tree? Sourceforge moved everything to a new layout, but didn't remove the old one. Current is https://svn.code.sf.net/p/reducealgebra/code/trunk Rainer > > BEGIN PGP SIGNED MESSAGE > Hash: SHA1 > > Hi, > > ah good, found it. > > Although when I created the manual I see that "realvalued" is not > included, it seems only to be in a file "aprop.tex" which is nowhere > included into the manual. Also the marvellous "in_tex" command does > not seem to be documented at all in the manual. > > Tony > > PS If anyone else also likes, I generate a nice size for reading on > screen (instead of printing) by the header > \ifcase2 > \or\documentclass[11pt,a4paper]{book} > \or\documentclass[11pt,a5paper]{book} > \usepackage[a5paper,margin=10.7mm]{geometry} > \fi > It has almost exactly the same line breaks > > > On 15/11/13 5:05 PM, Rainer Sch??f wrote: > > Hi, > > > > the manual is being updated; the current version is part of the SVN > > repository (in the doc/manual subtree). > > > > I guess I could put the HTML version of that on the web page. > > > > Rainer > > > > > > On Fri, 15 Nov 2013 at 09:51 +1030, Tony Roberts wrote: > > > >> Hi, > >> > >> nice to know about realvalued command, I would have liked to use > >> it last year. > >> > >> Is there any effort under way to update the Reduce manual to > >> reflect the developments being made? I am only aware of the 2004 > >> manual. Or is the team looking for someone to do it? > >> > >> Tony > >> > >> On 14/11/13 6:12 PM, Arthur Norman wrote: > >>> On Wed, 13 Nov 2013, Bard Ermentrout wrote: > >>>> I am not sure if this is the right place to send questions > >>>> and I am sorry if it is not. > >>> Yes this is a good place to ask... > >>> > >>>> How do I declare, say x and y to be real so that say, > >>>> conj(x+i*y)=xi*y? And how do I declare m to be an integer > >>>> so int(sin(m*x),x,0,2*pi) =0 > >>>> > >>> > >>> Part of your question may be addressed if I transcribe > >>> comments from the code in packages/poly/compopr.red, which may > >>> say more than the manual does! > >>> > >>> % The following code attempts to improve the way that the > >>> complex % operators CONJ, REPART and IMPART handle values that > >>> are implicitly % real, namely composed "realitypreserving" > >>> functions of explicitly % real numbers, implicitly real > >>> symbolic constants and variables that % the user has declared > >>> using the REALVALUED command defined below. > >>> > >>> % All arithmetic operations, direct trig functions and the > >>> exponential % function are "realitypreserving", but inverse > >>> trig functions and the % logarithm are "realitypreserving" > >>> only for real arguments in a % restricted range. This relates > >>> to piecewisedefined functions! This % code is believed to make > >>> the right decision about implicit reality in % straightforward > >>> cases, and otherwise errs on the side of caution and % makes no > >>> assumption at all, as does the standard REDUCE 3.4 code. It % > >>> performs only very limited numerical evaluation, which should > >>> be very % fast. It never performs any approximate numerical > >>> evaluation, or any % sophisticated analysis, both of which > >>> would be much slower and/or % complicated. The current strategy > >>> is believed to represent a % reasonable compromise, and will > >>> normally give the user what they % expect without undue > >>> overhead. > >>> > >>> symbolic procedure realvalued u; % Command to allow the user > >>> to declare functions or variables to be % implicitly real > >>> valued. <<rmsubs(); % So that an expression can be > >>> reevaluated. for each v in u do if not idp v then > >>> typerr(v,"id") else flag(list v,'realvalued)>>; > >>> > >>> symbolic procedure notrealvalued u; % Undo realvalued > >>> declaration. % Cannot recover "complexity", so no need for > >>> rmsubs(). for each v in u do if not idp v then typerr(v,"id") > >>> else remflag(list v, 'realvalued); > >>> > >>> flag('(realvaluedp),'boolean); % Make realvaluedp available in > >>> % algebraic mode. > >>> > >>> ============ So a statement realvalued x, y; will tend to help, > >>> as in > >>> > >>> Reduce (Free CSL version), 04Nov13 ... > >>> > >>> 1: conj(x + i*y); > >>> > >>>  impart(x)*i  impart(y) + repart(x)  repart(y)*i > >>> > >>> 2: realvalued x, y; > >>> > >>> 3: conj(x + i*y); > >>> > >>> > >>>  i*y + x > >>> > >>> > >>> > >>> > >>> > >>> Arthur > >>> > >>> > >>> >  > > > >>> > >> > >>> > >> DreamFactory  Open Source REST & JSON Services for HTML5 & > >> Native Apps > >>> OAuth, Users, Roles, SQL, NoSQL, BLOB Storage and External API > >>> Access Free app hosting. Or install the open source package on > >>> any LAMP server. Sign up and see examples for AngularJS, > >>> jQuery, Sencha Touch and Native! > >>> > http://pubads.g.doubleclick.net/gampad/clk?id=63469471&iu=/4140/ostg.clktrk > > > >>> > >> > >>> > >> _______________________________________________ > >>> Reducealgebradevelopers mailing list > >>> Reducealgebradevelopers@... > >>> > https://lists.sourceforge.net/lists/listinfo/reducealgebradevelopers > > > >>> > >> > >>> > >> . > >>> > >> > >>  > >>  > > > >> > > Professor A.J. Roberts > >> School of Mathematical Sciences phone: +61 8 8313 3035 > >> University of Adelaide fax: +61 8 8313 3696 South > >> Australia 5005. > >> mailto:anthony.roberts@... > >> http://www.maths.adelaide.edu.au/anthony.roberts/ > >> ==.0000001000000100000110001000011010001111110010111011101000010000== > > > >> > > > >> [ PGP Signature check FAILED  Fr 15. Nov 07:29:29 CET 2013 ] > >> > > > > Rainer Sch??f > >   >   > Professor A.J. Roberts > School of Mathematical Sciences phone: +61 8 8313 3035 > University of Adelaide fax: +61 8 8313 3696 > South Australia 5005. mailto:anthony.roberts@... > http://www.maths.adelaide.edu.au/anthony.roberts/ > ==.0000001000000100000110001000011010001111110010111011101000010000== > > BEGIN PGP SIGNATURE > Version: GnuPG v1.4.10 (Darwin) > Comment: Using GnuPG with Mozilla  http://enigmail.mozdev.org/ > > iEYEARECAAYFAlKGdvIACgkQ7TX8dTbro1s59wCeN/HpcnsczoARZGHzcnSpvWoj > 0YoAnRINFZ8PR4L89Tkkn/ncl6kHTGOk > =VDpY > END PGP SIGNATURE > Rainer Schöpf 
From: Bard Ermentrout <ermentrout@gm...>  20131116 00:17:19

Is there any way to differentiate under the integral sign. I'd like to define a function: int(exp(a*cos(x)),x,0,pi); and then get a Taylor series approximation of it in terms of a. Reduce does not understand how to differentiate under the integra sign to get a bunch of simple integrals of powers of cos(x) Regards  Bard Ermentrout 
From: Tony Roberts <anthony.roberts@ad...>  20131115 19:33:23

BEGIN PGP SIGNED MESSAGE Hash: SHA1 Hi, ah good, found it. Although when I created the manual I see that "realvalued" is not included, it seems only to be in a file "aprop.tex" which is nowhere included into the manual. Also the marvellous "in_tex" command does not seem to be documented at all in the manual. Tony PS If anyone else also likes, I generate a nice size for reading on screen (instead of printing) by the header \ifcase2 \or\documentclass[11pt,a4paper]{book} \or\documentclass[11pt,a5paper]{book} \usepackage[a5paper,margin=10.7mm]{geometry} \fi It has almost exactly the same line breaks On 15/11/13 5:05 PM, Rainer Schöpf wrote: > Hi, > > the manual is being updated; the current version is part of the SVN > repository (in the doc/manual subtree). > > I guess I could put the HTML version of that on the web page. > > Rainer > > > On Fri, 15 Nov 2013 at 09:51 +1030, Tony Roberts wrote: > >> Hi, >> >> nice to know about realvalued command, I would have liked to use >> it last year. >> >> Is there any effort under way to update the Reduce manual to >> reflect the developments being made? I am only aware of the 2004 >> manual. Or is the team looking for someone to do it? >> >> Tony >> >> On 14/11/13 6:12 PM, Arthur Norman wrote: >>> On Wed, 13 Nov 2013, Bard Ermentrout wrote: >>>> I am not sure if this is the right place to send questions >>>> and I am sorry if it is not. >>> Yes this is a good place to ask... >>> >>>> How do I declare, say x and y to be real so that say, >>>> conj(x+i*y)=xi*y? And how do I declare m to be an integer >>>> so int(sin(m*x),x,0,2*pi) =0 >>>> >>> >>> Part of your question may be addressed if I transcribe >>> comments from the code in packages/poly/compopr.red, which may >>> say more than the manual does! >>> >>> % The following code attempts to improve the way that the >>> complex % operators CONJ, REPART and IMPART handle values that >>> are implicitly % real, namely composed "realitypreserving" >>> functions of explicitly % real numbers, implicitly real >>> symbolic constants and variables that % the user has declared >>> using the REALVALUED command defined below. >>> >>> % All arithmetic operations, direct trig functions and the >>> exponential % function are "realitypreserving", but inverse >>> trig functions and the % logarithm are "realitypreserving" >>> only for real arguments in a % restricted range. This relates >>> to piecewisedefined functions! This % code is believed to make >>> the right decision about implicit reality in % straightforward >>> cases, and otherwise errs on the side of caution and % makes no >>> assumption at all, as does the standard REDUCE 3.4 code. It % >>> performs only very limited numerical evaluation, which should >>> be very % fast. It never performs any approximate numerical >>> evaluation, or any % sophisticated analysis, both of which >>> would be much slower and/or % complicated. The current strategy >>> is believed to represent a % reasonable compromise, and will >>> normally give the user what they % expect without undue >>> overhead. >>> >>> symbolic procedure realvalued u; % Command to allow the user >>> to declare functions or variables to be % implicitly real >>> valued. <<rmsubs(); % So that an expression can be >>> reevaluated. for each v in u do if not idp v then >>> typerr(v,"id") else flag(list v,'realvalued)>>; >>> >>> symbolic procedure notrealvalued u; % Undo realvalued >>> declaration. % Cannot recover "complexity", so no need for >>> rmsubs(). for each v in u do if not idp v then typerr(v,"id") >>> else remflag(list v, 'realvalued); >>> >>> flag('(realvaluedp),'boolean); % Make realvaluedp available in >>> % algebraic mode. >>> >>> ============ So a statement realvalued x, y; will tend to help, >>> as in >>> >>> Reduce (Free CSL version), 04Nov13 ... >>> >>> 1: conj(x + i*y); >>> >>>  impart(x)*i  impart(y) + repart(x)  repart(y)*i >>> >>> 2: realvalued x, y; >>> >>> 3: conj(x + i*y); >>> >>> >>>  i*y + x >>> >>> >>> >>> >>> >>> Arthur >>> >>> >>>  > >>> >> >>> >> DreamFactory  Open Source REST & JSON Services for HTML5 & >> Native Apps >>> OAuth, Users, Roles, SQL, NoSQL, BLOB Storage and External API >>> Access Free app hosting. Or install the open source package on >>> any LAMP server. Sign up and see examples for AngularJS, >>> jQuery, Sencha Touch and Native! >>> http://pubads.g.doubleclick.net/gampad/clk?id=63469471&iu=/4140/ostg.clktrk > >>> >> >>> >> _______________________________________________ >>> Reducealgebradevelopers mailing list >>> Reducealgebradevelopers@... >>> https://lists.sourceforge.net/lists/listinfo/reducealgebradevelopers > >>> >> >>> >> . >>> >> >>  >>  > >> > Professor A.J. Roberts >> School of Mathematical Sciences phone: +61 8 8313 3035 >> University of Adelaide fax: +61 8 8313 3696 South >> Australia 5005. >> mailto:anthony.roberts@... >> http://www.maths.adelaide.edu.au/anthony.roberts/ >> ==.0000001000000100000110001000011010001111110010111011101000010000== > >> > >> [ PGP Signature check FAILED  Fr 15. Nov 07:29:29 CET 2013 ] >> > > Rainer Schöpf     Professor A.J. Roberts School of Mathematical Sciences phone: +61 8 8313 3035 University of Adelaide fax: +61 8 8313 3696 South Australia 5005. mailto:anthony.roberts@... http://www.maths.adelaide.edu.au/anthony.roberts/ ==.0000001000000100000110001000011010001111110010111011101000010000== BEGIN PGP SIGNATURE Version: GnuPG v1.4.10 (Darwin) Comment: Using GnuPG with Mozilla  http://enigmail.mozdev.org/ iEYEARECAAYFAlKGdvIACgkQ7TX8dTbro1s59wCeN/HpcnsczoARZGHzcnSpvWoj 0YoAnRINFZ8PR4L89Tkkn/ncl6kHTGOk =VDpY END PGP SIGNATURE 
From: Rainer Schöpf <rainer.schoepf@gm...>  20131115 07:35:40

Only small corrections have been done to the limit module since its author, Stan Kameny, passed away. A lot of the code relies on being able to expand the expression in question into a power series around the limit point. This doesn't work for essential singularities. Indeed, the three limits here don't exist in the complex domain. For limits around infinity, the code tries to substitute x > 1/x^2 to transform to point 0. For x/(e^x + 1), this gives 1/(e^(1/x^2)*x^2+x^2) which is difficult to handle using L'Hopital's rule. Obviously, this needs a major review. Rainer On Thu, 14 Nov 2013 at 21:17 0000, Arthur Norman wrote: > I observe that > limit(1/(e^x + 1), x, infinity) => 0 > limit(x/(e^x + 1), x, infinity) => unsimplified > limit(x/e^x, x, infinity) => 0 > so there is a jolly project for somebody to trace through and see what it > is doing there! I rather wonder if it is because e^x only goes to > +infinity if you approach x=infinity eg along the positive real axis  > otherwise you have an essential singularity there. And possibly the code > that copes (sometimes) with essential singularities is being really > cautious...???? > I need to sleep right now rather than to dive into the code and see just > what it is up to. > Arthur > > On Thu, 14 Nov 2013, Bard Ermentrout wrote: > > > I have been playing with reduce now for a bit and I was puzzled by the > > inability of the limit function to get this limit and don't know if this is > > a bug or not: > > limit((x^2+5*x)/(exp(x)+x),x,infinity); > > > > while it gets > > > > > > limit((x^2+5*x)/(exp(x)),x,infinity); > > fine > > > > It must have very specific rules  certainly repeated application of > > L'hopitals rule would work here > > > > Bard Ermentout > > > >  > DreamFactory  Open Source REST & JSON Services for HTML5 & Native Apps > OAuth, Users, Roles, SQL, NoSQL, BLOB Storage and External API Access > Free app hosting. Or install the open source package on any LAMP server. > Sign up and see examples for AngularJS, jQuery, Sencha Touch and Native! > http://pubads.g.doubleclick.net/gampad/clk?id=63469471&iu=/4140/ostg.clktrk > _______________________________________________ > Reducealgebradevelopers mailing list > Reducealgebradevelopers@... > https://lists.sourceforge.net/lists/listinfo/reducealgebradevelopers > Rainer Schöpf 
From: Rainer Schöpf <rainer.schoepf@gm...>  20131115 06:35:52

Hi, the manual is being updated; the current version is part of the SVN repository (in the doc/manual subtree). I guess I could put the HTML version of that on the web page. Rainer On Fri, 15 Nov 2013 at 09:51 +1030, Tony Roberts wrote: > Hi, > > nice to know about realvalued command, I would have liked to use it > last year. > > Is there any effort under way to update the Reduce manual to reflect > the developments being made? I am only aware of the 2004 manual. Or > is the team looking for someone to do it? > > Tony > > On 14/11/13 6:12 PM, Arthur Norman wrote: > > On Wed, 13 Nov 2013, Bard Ermentrout wrote: > >> I am not sure if this is the right place to send questions and I > >> am sorry if it is not. > > Yes this is a good place to ask... > > > >> How do I declare, say x and y to be real so that say, > >> conj(x+i*y)=xi*y? And how do I declare m to be an integer so > >> int(sin(m*x),x,0,2*pi) =0 > >> > > > > Part of your question may be addressed if I transcribe comments > > from the code in packages/poly/compopr.red, which may say more than > > the manual does! > > > > % The following code attempts to improve the way that the complex % > > operators CONJ, REPART and IMPART handle values that are > > implicitly % real, namely composed "realitypreserving" functions > > of explicitly % real numbers, implicitly real symbolic constants > > and variables that % the user has declared using the REALVALUED > > command defined below. > > > > % All arithmetic operations, direct trig functions and the > > exponential % function are "realitypreserving", but inverse trig > > functions and the % logarithm are "realitypreserving" only for > > real arguments in a % restricted range. This relates to > > piecewisedefined functions! This % code is believed to make the > > right decision about implicit reality in % straightforward cases, > > and otherwise errs on the side of caution and % makes no assumption > > at all, as does the standard REDUCE 3.4 code. It % performs only > > very limited numerical evaluation, which should be very % fast. It > > never performs any approximate numerical evaluation, or any % > > sophisticated analysis, both of which would be much slower and/or % > > complicated. The current strategy is believed to represent a % > > reasonable compromise, and will normally give the user what they % > > expect without undue overhead. > > > > symbolic procedure realvalued u; % Command to allow the user to > > declare functions or variables to be % implicitly real valued. > > <<rmsubs(); % So that an expression can be reevaluated. for each > > v in u do if not idp v then typerr(v,"id") else flag(list > > v,'realvalued)>>; > > > > symbolic procedure notrealvalued u; % Undo realvalued declaration. > > % Cannot recover "complexity", so no need for rmsubs(). for each v > > in u do if not idp v then typerr(v,"id") else remflag(list v, > > 'realvalued); > > > > flag('(realvaluedp),'boolean); % Make realvaluedp available in % > > algebraic mode. > > > > ============ So a statement realvalued x, y; will tend to help, as > > in > > > > Reduce (Free CSL version), 04Nov13 ... > > > > 1: conj(x + i*y); > > > >  impart(x)*i  impart(y) + repart(x)  repart(y)*i > > > > 2: realvalued x, y; > > > > 3: conj(x + i*y); > > > > > >  i*y + x > > > > > > > > > > > > Arthur > > > > > >  > > > > > DreamFactory  Open Source REST & JSON Services for HTML5 & Native Apps > > OAuth, Users, Roles, SQL, NoSQL, BLOB Storage and External API > > Access Free app hosting. Or install the open source package on any > > LAMP server. Sign up and see examples for AngularJS, jQuery, Sencha > > Touch and Native! > > http://pubads.g.doubleclick.net/gampad/clk?id=63469471&iu=/4140/ostg.clktrk > > > > > _______________________________________________ > > Reducealgebradevelopers mailing list > > Reducealgebradevelopers@... > > https://lists.sourceforge.net/lists/listinfo/reducealgebradevelopers > > > > > . > > > >  >  > Professor A.J. Roberts > School of Mathematical Sciences phone: +61 8 8313 3035 > University of Adelaide fax: +61 8 8313 3696 > South Australia 5005. mailto:anthony.roberts@... > http://www.maths.adelaide.edu.au/anthony.roberts/ > ==.0000001000000100000110001000011010001111110010111011101000010000== > > [ PGP Signature check FAILED  Fr 15. Nov 07:29:29 CET 2013 ] > Rainer Schöpf 
From: Tony Roberts <anthony.roberts@ad...>  20131114 23:35:11

BEGIN PGP SIGNED MESSAGE Hash: SHA1 Hi, nice to know about realvalued command, I would have liked to use it last year. Is there any effort under way to update the Reduce manual to reflect the developments being made? I am only aware of the 2004 manual. Or is the team looking for someone to do it? Tony On 14/11/13 6:12 PM, Arthur Norman wrote: > On Wed, 13 Nov 2013, Bard Ermentrout wrote: >> I am not sure if this is the right place to send questions and I >> am sorry if it is not. > Yes this is a good place to ask... > >> How do I declare, say x and y to be real so that say, >> conj(x+i*y)=xi*y? And how do I declare m to be an integer so >> int(sin(m*x),x,0,2*pi) =0 >> > > Part of your question may be addressed if I transcribe comments > from the code in packages/poly/compopr.red, which may say more than > the manual does! > > % The following code attempts to improve the way that the complex % > operators CONJ, REPART and IMPART handle values that are > implicitly % real, namely composed "realitypreserving" functions > of explicitly % real numbers, implicitly real symbolic constants > and variables that % the user has declared using the REALVALUED > command defined below. > > % All arithmetic operations, direct trig functions and the > exponential % function are "realitypreserving", but inverse trig > functions and the % logarithm are "realitypreserving" only for > real arguments in a % restricted range. This relates to > piecewisedefined functions! This % code is believed to make the > right decision about implicit reality in % straightforward cases, > and otherwise errs on the side of caution and % makes no assumption > at all, as does the standard REDUCE 3.4 code. It % performs only > very limited numerical evaluation, which should be very % fast. It > never performs any approximate numerical evaluation, or any % > sophisticated analysis, both of which would be much slower and/or % > complicated. The current strategy is believed to represent a % > reasonable compromise, and will normally give the user what they % > expect without undue overhead. > > symbolic procedure realvalued u; % Command to allow the user to > declare functions or variables to be % implicitly real valued. > <<rmsubs(); % So that an expression can be reevaluated. for each > v in u do if not idp v then typerr(v,"id") else flag(list > v,'realvalued)>>; > > symbolic procedure notrealvalued u; % Undo realvalued declaration. > % Cannot recover "complexity", so no need for rmsubs(). for each v > in u do if not idp v then typerr(v,"id") else remflag(list v, > 'realvalued); > > flag('(realvaluedp),'boolean); % Make realvaluedp available in % > algebraic mode. > > ============ So a statement realvalued x, y; will tend to help, as > in > > Reduce (Free CSL version), 04Nov13 ... > > 1: conj(x + i*y); > >  impart(x)*i  impart(y) + repart(x)  repart(y)*i > > 2: realvalued x, y; > > 3: conj(x + i*y); > > >  i*y + x > > > > > > Arthur > > >  > > DreamFactory  Open Source REST & JSON Services for HTML5 & Native Apps > OAuth, Users, Roles, SQL, NoSQL, BLOB Storage and External API > Access Free app hosting. Or install the open source package on any > LAMP server. Sign up and see examples for AngularJS, jQuery, Sencha > Touch and Native! > http://pubads.g.doubleclick.net/gampad/clk?id=63469471&iu=/4140/ostg.clktrk > > _______________________________________________ > Reducealgebradevelopers mailing list > Reducealgebradevelopers@... > https://lists.sourceforge.net/lists/listinfo/reducealgebradevelopers > > . >     Professor A.J. Roberts School of Mathematical Sciences phone: +61 8 8313 3035 University of Adelaide fax: +61 8 8313 3696 South Australia 5005. mailto:anthony.roberts@... http://www.maths.adelaide.edu.au/anthony.roberts/ ==.0000001000000100000110001000011010001111110010111011101000010000== BEGIN PGP SIGNATURE Version: GnuPG v1.4.10 (Darwin) Comment: Using GnuPG with Mozilla  http://enigmail.mozdev.org/ iEYEARECAAYFAlKFWwkACgkQ7TX8dTbro1si5gCffKG/hRpqN/0SVrkxB4YNaAs+ mo8An2c/cF/9ZwBXY5c4V0lvtsqXhh6Y =2vWv END PGP SIGNATURE 
From: Arthur Norman <acn1@ca...>  20131114 21:17:52

I observe that limit(1/(e^x + 1), x, infinity) => 0 limit(x/(e^x + 1), x, infinity) => unsimplified limit(x/e^x, x, infinity) => 0 so there is a jolly project for somebody to trace through and see what it is doing there! I rather wonder if it is because e^x only goes to +infinity if you approach x=infinity eg along the positive real axis  otherwise you have an essential singularity there. And possibly the code that copes (sometimes) with essential singularities is being really cautious...???? I need to sleep right now rather than to dive into the code and see just what it is up to. Arthur On Thu, 14 Nov 2013, Bard Ermentrout wrote: > I have been playing with reduce now for a bit and I was puzzled by the > inability of the limit function to get this limit and don't know if this is > a bug or not: > limit((x^2+5*x)/(exp(x)+x),x,infinity); > > while it gets > > > limit((x^2+5*x)/(exp(x)),x,infinity); > fine > > It must have very specific rules  certainly repeated application of > L'hopitals rule would work here > > Bard Ermentout > 
From: Bard Ermentrout <ermentrout@gm...>  20131114 20:35:36

I have been playing with reduce now for a bit and I was puzzled by the inability of the limit function to get this limit and don't know if this is a bug or not: limit((x^2+5*x)/(exp(x)+x),x,infinity); while it gets limit((x^2+5*x)/(exp(x)),x,infinity); fine It must have very specific rules  certainly repeated application of L'hopitals rule would work here Bard Ermentout On Wed, Nov 13, 2013 at 10:48 PM, Bard Ermentrout <ermentrout@...>wrote: > I am not sure if this is the right place to send questions and I am sorry > if it is not. > How do I declare, say x and y to be real so that say, conj(x+i*y)=xi*y? > And how do I declare m to be an integer so int(sin(m*x),x,0,2*pi) =0 > > > >  > Bard >  Bard 
From: Arthur Norman <acn1@ca...>  20131114 07:42:36

On Wed, 13 Nov 2013, Bard Ermentrout wrote: > I am not sure if this is the right place to send questions and I am sorry > if it is not. Yes this is a good place to ask... > How do I declare, say x and y to be real so that say, conj(x+i*y)=xi*y? > And how do I declare m to be an integer so int(sin(m*x),x,0,2*pi) =0 > Part of your question may be addressed if I transcribe comments from the code in packages/poly/compopr.red, which may say more than the manual does! % The following code attempts to improve the way that the complex % operators CONJ, REPART and IMPART handle values that are implicitly % real, namely composed "realitypreserving" functions of explicitly % real numbers, implicitly real symbolic constants and variables that % the user has declared using the REALVALUED command defined below. % All arithmetic operations, direct trig functions and the exponential % function are "realitypreserving", but inverse trig functions and the % logarithm are "realitypreserving" only for real arguments in a % restricted range. This relates to piecewisedefined functions! This % code is believed to make the right decision about implicit reality in % straightforward cases, and otherwise errs on the side of caution and % makes no assumption at all, as does the standard REDUCE 3.4 code. It % performs only very limited numerical evaluation, which should be very % fast. It never performs any approximate numerical evaluation, or any % sophisticated analysis, both of which would be much slower and/or % complicated. The current strategy is believed to represent a % reasonable compromise, and will normally give the user what they % expect without undue overhead. symbolic procedure realvalued u; % Command to allow the user to declare functions or variables to be % implicitly real valued. <<rmsubs(); % So that an expression can be reevaluated. for each v in u do if not idp v then typerr(v,"id") else flag(list v,'realvalued)>>; symbolic procedure notrealvalued u; % Undo realvalued declaration. % Cannot recover "complexity", so no need for rmsubs(). for each v in u do if not idp v then typerr(v,"id") else remflag(list v, 'realvalued); flag('(realvaluedp),'boolean); % Make realvaluedp available in % algebraic mode. ============ So a statement realvalued x, y; will tend to help, as in Reduce (Free CSL version), 04Nov13 ... 1: conj(x + i*y);  impart(x)*i  impart(y) + repart(x)  repart(y)*i 2: realvalued x, y; 3: conj(x + i*y);  i*y + x Arthur 
From: Bard Ermentrout <ermentrout@gm...>  20131114 03:48:35

I am not sure if this is the right place to send questions and I am sorry if it is not. How do I declare, say x and y to be real so that say, conj(x+i*y)=xi*y? And how do I declare m to be an integer so int(sin(m*x),x,0,2*pi) =0  Bard 