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}
(35) 
_{Sep}

_{Oct}

_{Nov}

_{Dec}

S  M  T  W  T  F  S 






1

2

3

4

5

6

7

8

9

10

11
(1) 
12
(3) 
13

14

15
(2) 
16
(2) 
17

18

19
(3) 
20

21
(2) 
22
(2) 
23

24

25

26
(1) 
27
(2) 
28

29

30

31







From: Rainer Schöpf <rainer.schoepf@gm...>  20110716 19:54:48

On Fri, 15 Jul 2011 at 14:18 0400, Ted Kosan wrote: > This past May I submitted the following question to the Reduce forum > which was about turning off automatic simplification: > > http://sourceforge.net/projects/reducealgebra/forums/forum/899364/topic/4499010 > > The revalp code that Tony submitted provides a partial solution, but a > full solution would allow functions like NUM, DEN, and SUB to be used > on the expression so that it can be analysed and manipulated. At one > point I thought that I could add this feature myself, but I found that > I will have to study Rlisp further before I have the skills needed to > do it properly. Actually, you have to understand how the simplification process works (basically what the functions in packages/alg/reval.red do). The problem here is that things that look similar in function may be quite different. NUM/DEN are good examples: the argument of these operators is fully simplified before the actual numerator or denominator is taken. Which is to say right now that they will not work in "nosimp" (ie. OFF REVALP) mode. The same goes for SUB: substitution happens by simplifying and converting the expression into a standard quotient and descending into the constituents of this standard representation, performing the substitutions on the way. This is necessary to perform more complicated substitutions, like replacements for products of several terms. Consider a product like a*b*c in which you want to replace a*c by something else. Clearly this substitution must happen even if if there are many factors between a and c. On the other hand, PART and friends work on an expression "as it is", ie. without simplifying their arguments. So, accessing parts of an expression is possible even without simplification. I believe it would be possible to implement these "syntactical" access functions to work in nosimp mode. Variants of NUM/DEN could then be defined in terms of these functions: procedure NUM2 u; if ARGLENGTH u = 1 then u % number of symbol else if not (part(u,0)=quotient) then u % toplevel operator is not quotient else part(u,1); procedure DEN2 u; if ARGLENGTH u = 1 then u else if not (part(u,0)=quotient) then u else part(u,2); One could add definitions like these for many of the standard operators, to be used in nosimp mode, instead of the standard ones. This may be the easiest solution. > I am asking for this capability on behalf of the GeoGebra project > (http://GeoGebra.org) because they are in the process of adopting the > Java version of Reduce as the CAS computation engine for GeoGebra. By > the way, GeoGebra has millions of users worldwide and its level of > adoption continues to increase. They are very excited about the idea > of using the commercialquality Reduce CAS as the computation engine > for GeoGebra and their plan is to ship Reduce with the new GeoGebra > 4.0 in August. > > I have asked Simon Weitzhofer, who is a GeoGebra developer, to join > this email list so that he can provide more information on the > nosimplification feature that they need for GeoGebra. That would be very helpful. > I am hoping > that this feature can be added to Reduce without too much difficulty. Well, first of all we need to understand what is actually needed. Thanks, Rainer 
From: Ted Kosan <ted.kosan@gm...>  20110716 16:10:31

Rainer wrote: > More generally, one should have various boolean operators for testing type, at > least for those types that can be declared, like matrix, vector, etc. Here is a list of most of MathPiper's boolean operators just for reference: IsAmicablePair, IsAtom, IsBoolean, IsBound, IsCarmichaelNumber, IsComposite, IsConstant, IsCoprime, IsDecimal, IsDiagonal, IsEquation, IsEven, IsEvenFunction, IsFreeOf, IsFunction, IsGaussianInteger, IsGaussianPrime, IsGaussianUnit, IsGreaterThan, IsHermitian, IsIdempotent, IsInfinity, IsInfix, IsInteger, IsIrregularPrime, IsLessThan, IsList, IsListOfLists, IsLowerTriangular, IsMatrix, IsMonomial, IsNegativeInteger, IsNegativeNumber, IsNegativeReal, IsNonObject, IsNonZeroInteger, IsNotZero, IsNumber, IsNumericList, IsOdd, IsOddFunction, IsOrthogonal, IsPositiveInteger, IsPositiveNumber, IsPositiveReal, IsPostfix, IsPrefix, IsPrime, IsPrimePower, IsQuadraticResidue, IsRational, IsScalar, IsSkewSymmetric, IsSmallPrime, IsSquareFree, IsSquareMatrix, IsString, IsSumOfTerms, IsSymmetric, IsTwinPrime, IsUnitary, IsUpperTriangular, IsVector, IsZero, IsZeroVector. Ted 