You can subscribe to this list here.
2014 
_{Jan}

_{Feb}
(232) 
_{Mar}
(323) 
_{Apr}
(383) 
_{May}
(359) 
_{Jun}
(435) 
_{Jul}
(252) 
_{Aug}
(172) 
_{Sep}
(265) 
_{Oct}
(263) 
_{Nov}
(350) 
_{Dec}
(359) 

2015 
_{Jan}
(267) 
_{Feb}
(220) 
_{Mar}
(311) 
_{Apr}
(269) 
_{May}
(388) 
_{Jun}
(403) 
_{Jul}
(33) 
_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

From: Gunter Königsmann <gunter@pe...>  20150503 09:35:56

I am just a user, not one of the mathematics wizards that are in this list. But I think better inequality testing will add much to the experience with maxima: Currently when solving differential equations I always get asked thinks like: Is 4L>(R_1+R_2)*C even if it is known that the opposite is true and sometimes I cannot find an assume that gives the right answers and seem to be stuck with answering these questions manually. So thumbsup from me! Kind regards, Gunter. On So, Mai 3, 2015 at 11:22 , Mike Valenzuela <mickle.mouse@...> wrote: > I guess there are a bunch of rules on wikipedia > (http://en.wikipedia.org/wiki/Interval_arithmetic). I knew odd powers > were easy, but even powers were a bit easier than I was making them > out to be. Still if the exponent could be zero, then there is more to > worry about. I was also worrying about extending the intervals to > unknown even/odd powers. For symbolic odd powers, the bounds will > either grow toward negative infinity, towards 0, or towards infinity. > Depending on its previous value, whether the bound was an upper or > lower, this will impact the new bounds. > > [1/2, 2]^k, for a positive integer k. The new bounds are [1/2^k, > 2^k]. We can drop the variable k by considering all its possible > values. Then the bounds adjust to (0, inf). > > On Sun, May 3, 2015 at 2:14 AM, Stavros Macrakis (Σταῦρος > Μακράκης) <macrakis@...> wrote: >> I doubt there's much to be learned from a numeric interval library >> in writing a symbolic interval library that isn't obvious. >> >> On Sun, May 3, 2015 at 5:08 AM, Mike Valenzuela >> <mickle.mouse@...> wrote: >>> ninja edit. >>> >>> I have two parts to that rambling. At one point I was just worrying >>> about signs when I discovered it wasn't enough. I'll look into the >>> c++ boost library later to see if it is suitable for working with >>> symbolic intervals. >>> >>> On Sun, May 3, 2015 at 2:07 AM, Mike Valenzuela >>> <mickle.mouse@...> wrote: >>>> I have two parts to that rambling. At one point I was just >>>> worrying about signs when I discovered it was enough. >>>> >>>> I recently recalled the c++ boost interval library: >>>> http://www.boost.org/doc/libs/1_58_0/libs/numeric/interval/doc/interval.htm. >>>> I wonder if carrying out many of the same operations symbolically, >>>> if it would work. >>>> >>>> On Sun, May 3, 2015 at 1:44 AM, Stavros Macrakis (Σταῦρος >>>> Μακράκης) <macrakis@...> wrote: >>>>> (resending to group without Mike's code because moderation kicks >>>>> in for long messages) >>>>> >>>>> Thanks for your ideas. >>>>> >>>>> I haven't read your code (sorry), but it looks from the names >>>>> lower_ and upper_bound that you're doing some sort of symbolic >>>>> interval arithmetic, which would be a useful addition to Maxima. >>>>> Currently, Maxima doesn't do any of that, which is a bit >>>>> surprising. >>>>> >>>>> s >>>>> >>>>> On Sun, May 3, 2015 at 4:31 AM, Mike Valenzuela >>>>> <mickle.mouse@...> wrote: >>>>>> Hello all again, >>>>>> >>>>>> I've been trying to put together a rule list for working with >>>>>> inequalities, especially for testing, so I put together some >>>>>> rules.... >>>> >>> >>> >>>  >>> One dashboard for servers and applications across >>> PhysicalVirtualCloud >>> Widest outofthebox monitoring support with 50+ applications >>> Performance metrics, stats and reports that give you Actionable >>> Insights >>> Deep dive visibility with transaction tracing using APM Insight. >>> http://ad.doubleclick.net/ddm/clk/290420510;117567292;y >>> _______________________________________________ >>> Maximadiscuss mailing list >>> Maximadiscuss@... >>> https://lists.sourceforge.net/lists/listinfo/maximadiscuss >>> >> > 
From: Mike Valenzuela <mickle.mouse@gm...>  20150503 09:22:44

I guess there are a bunch of rules on wikipedia ( http://en.wikipedia.org/wiki/Interval_arithmetic). I knew odd powers were easy, but even powers were a bit easier than I was making them out to be. Still if the exponent could be zero, then there is more to worry about. I was also worrying about extending the intervals to unknown even/odd powers. For symbolic odd powers, the bounds will either grow toward negative infinity, towards 0, or towards infinity. Depending on its previous value, whether the bound was an upper or lower, this will impact the new bounds. [1/2, 2]^k, for a positive integer k. The new bounds are [1/2^k, 2^k]. We can drop the variable k by considering all its possible values. Then the bounds adjust to (0, inf). On Sun, May 3, 2015 at 2:14 AM, Stavros Macrakis (Σταῦρος Μακράκης) < macrakis@...> wrote: > I doubt there's much to be learned from a numeric interval library in > writing a symbolic interval library that isn't obvious. > > On Sun, May 3, 2015 at 5:08 AM, Mike Valenzuela <mickle.mouse@...> > wrote: > >> ninja edit. >> >> I have two parts to that rambling. At one point I was just worrying about >> signs when I discovered it *wasn't* enough. I'll look into the c++ boost >> library later to see if it is suitable for working with symbolic intervals. >> >> On Sun, May 3, 2015 at 2:07 AM, Mike Valenzuela <mickle.mouse@...> >> wrote: >> >>> I have two parts to that rambling. At one point I was just worrying >>> about signs when I discovered it was enough. >>> >>> I recently recalled the c++ boost interval library: >>> http://www.boost.org/doc/libs/1_58_0/libs/numeric/interval/doc/interval.htm. >>> I wonder if carrying out many of the same operations symbolically, if it >>> would work. >>> >>> On Sun, May 3, 2015 at 1:44 AM, Stavros Macrakis (Σταῦρος Μακράκης) < >>> macrakis@...> wrote: >>> >>>> (resending to group without Mike's code because moderation kicks in for >>>> long messages) >>>> >>>> Thanks for your ideas. >>>> >>>> I haven't read your code (sorry), but it looks from the names lower_ >>>> and upper_bound that you're doing some sort of symbolic interval >>>> arithmetic, which would be a useful addition to Maxima. Currently, Maxima >>>> doesn't do any of that, which is a bit surprising. >>>> >>>> s >>>> >>>> On Sun, May 3, 2015 at 4:31 AM, Mike Valenzuela <mickle.mouse@... >>>> > wrote: >>>> >>>>> Hello all again, >>>>> >>>>> I've been trying to put together a rule list for working with >>>>> inequalities, especially for testing, so I put together some rules >>>>> .... >>>>> >>>> >>> >> >> >>  >> One dashboard for servers and applications across PhysicalVirtualCloud >> Widest outofthebox monitoring support with 50+ applications >> Performance metrics, stats and reports that give you Actionable Insights >> Deep dive visibility with transaction tracing using APM Insight. >> http://ad.doubleclick.net/ddm/clk/290420510;117567292;y >> _______________________________________________ >> Maximadiscuss mailing list >> Maximadiscuss@... >> https://lists.sourceforge.net/lists/listinfo/maximadiscuss >> >> > 
From: Stavros Macrakis (Σταῦρος Μακράκης) <macrakis@al...>  20150503 09:14:27

I doubt there's much to be learned from a numeric interval library in writing a symbolic interval library that isn't obvious. On Sun, May 3, 2015 at 5:08 AM, Mike Valenzuela <mickle.mouse@...> wrote: > ninja edit. > > I have two parts to that rambling. At one point I was just worrying about > signs when I discovered it *wasn't* enough. I'll look into the c++ boost > library later to see if it is suitable for working with symbolic intervals. > > On Sun, May 3, 2015 at 2:07 AM, Mike Valenzuela <mickle.mouse@...> > wrote: > >> I have two parts to that rambling. At one point I was just worrying about >> signs when I discovered it was enough. >> >> I recently recalled the c++ boost interval library: >> http://www.boost.org/doc/libs/1_58_0/libs/numeric/interval/doc/interval.htm. >> I wonder if carrying out many of the same operations symbolically, if it >> would work. >> >> On Sun, May 3, 2015 at 1:44 AM, Stavros Macrakis (Σταῦρος Μακράκης) < >> macrakis@...> wrote: >> >>> (resending to group without Mike's code because moderation kicks in for >>> long messages) >>> >>> Thanks for your ideas. >>> >>> I haven't read your code (sorry), but it looks from the names lower_ and >>> upper_bound that you're doing some sort of symbolic interval arithmetic, >>> which would be a useful addition to Maxima. Currently, Maxima doesn't do >>> any of that, which is a bit surprising. >>> >>> s >>> >>> On Sun, May 3, 2015 at 4:31 AM, Mike Valenzuela <mickle.mouse@...> >>> wrote: >>> >>>> Hello all again, >>>> >>>> I've been trying to put together a rule list for working with >>>> inequalities, especially for testing, so I put together some rules >>>> .... >>>> >>> >> > > >  > One dashboard for servers and applications across PhysicalVirtualCloud > Widest outofthebox monitoring support with 50+ applications > Performance metrics, stats and reports that give you Actionable Insights > Deep dive visibility with transaction tracing using APM Insight. > http://ad.doubleclick.net/ddm/clk/290420510;117567292;y > _______________________________________________ > Maximadiscuss mailing list > Maximadiscuss@... > https://lists.sourceforge.net/lists/listinfo/maximadiscuss > > 
From: Mike Valenzuela <mickle.mouse@gm...>  20150503 09:09:07

ninja edit. I have two parts to that rambling. At one point I was just worrying about signs when I discovered it *wasn't* enough. I'll look into the c++ boost library later to see if it is suitable for working with symbolic intervals. On Sun, May 3, 2015 at 2:07 AM, Mike Valenzuela <mickle.mouse@...> wrote: > I have two parts to that rambling. At one point I was just worrying about > signs when I discovered it was enough. > > I recently recalled the c++ boost interval library: > http://www.boost.org/doc/libs/1_58_0/libs/numeric/interval/doc/interval.htm. > I wonder if carrying out many of the same operations symbolically, if it > would work. > > On Sun, May 3, 2015 at 1:44 AM, Stavros Macrakis (Σταῦρος Μακράκης) < > macrakis@...> wrote: > >> (resending to group without Mike's code because moderation kicks in for >> long messages) >> >> Thanks for your ideas. >> >> I haven't read your code (sorry), but it looks from the names lower_ and >> upper_bound that you're doing some sort of symbolic interval arithmetic, >> which would be a useful addition to Maxima. Currently, Maxima doesn't do >> any of that, which is a bit surprising. >> >> s >> >> On Sun, May 3, 2015 at 4:31 AM, Mike Valenzuela <mickle.mouse@...> >> wrote: >> >>> Hello all again, >>> >>> I've been trying to put together a rule list for working with >>> inequalities, especially for testing, so I put together some rules >>> .... >>> >> > 
From: Mike Valenzuela <mickle.mouse@gm...>  20150503 09:07:53

I have two parts to that rambling. At one point I was just worrying about signs when I discovered it was enough. I recently recalled the c++ boost interval library: http://www.boost.org/doc/libs/1_58_0/libs/numeric/interval/doc/interval.htm. I wonder if carrying out many of the same operations symbolically, if it would work. On Sun, May 3, 2015 at 1:44 AM, Stavros Macrakis (Σταῦρος Μακράκης) < macrakis@...> wrote: > (resending to group without Mike's code because moderation kicks in for > long messages) > > Thanks for your ideas. > > I haven't read your code (sorry), but it looks from the names lower_ and > upper_bound that you're doing some sort of symbolic interval arithmetic, > which would be a useful addition to Maxima. Currently, Maxima doesn't do > any of that, which is a bit surprising. > > s > > On Sun, May 3, 2015 at 4:31 AM, Mike Valenzuela <mickle.mouse@...> > wrote: > >> Hello all again, >> >> I've been trying to put together a rule list for working with >> inequalities, especially for testing, so I put together some rules >> .... >> > 
From: Stavros Macrakis (Σταῦρος Μακράκης) <macrakis@al...>  20150503 08:44:21

(resending to group without Mike's code because moderation kicks in for long messages) Thanks for your ideas. I haven't read your code (sorry), but it looks from the names lower_ and upper_bound that you're doing some sort of symbolic interval arithmetic, which would be a useful addition to Maxima. Currently, Maxima doesn't do any of that, which is a bit surprising. s On Sun, May 3, 2015 at 4:31 AM, Mike Valenzuela <mickle.mouse@...> wrote: > Hello all again, > > I've been trying to put together a rule list for working with > inequalities, especially for testing, so I put together some rules > .... > 
From: Stavros Macrakis (Σταῦρος Μακράκης) <macrakis@al...>  20150503 08:41:48

Thanks for your ideas. I haven't read your code (sorry), but it looks from the names lower_ and upper_bound that you're doing some sort of symbolic interval arithmetic, which would be a useful addition to Maxima. Currently, Maxima doesn't do any of that, which is a bit surprising. s On Sun, May 3, 2015 at 4:31 AM, Mike Valenzuela <mickle.mouse@...> wrote: > Hello all again, > > I've been trying to put together a rule list for working with > inequalities, especially for testing, so I put together some rules (they > need double, triple, etc. checking). I got pretty tired so I don't even > know if this mailing list will understand what I wrote. I suspect these > rules can be vastly improved, probably compressed, and overall made more > accurate and complete. This is sort of a work in progress and is not even > ready for Maxima, so I haven't even moved this to git yet. I just do not > want to invest anymore time into this project if someone already has a > solution. If no one has a better solution for testing inequalities, then > maybe the following text could be converted into test cases and eventually > a lisp or Maxima routine can be written. > > > I release the following mistake ridden ramblings of a tired crazy person > under the GPL3 license. (I don't even know if I have to say as much). > /* Revisions to do: */ > /* > * > * To extend the following to multiple intervals, perform it on each > interval one at a time > * > * Unless stated bounds are (inf,inf) > * > * pedantic_flag = true by default, but may be set to false to allow 0^0 = > 1. > * > * TODO Add power support > * what if lower_bound=upper_bound? Should we error on (4,4] and [4,4) > or treat it as [4,4]? > * > * Note all power laws here assume lower_bound and upper_bound refer to > the base's lower and upper bounds > * if exponent is a positive, even integer > * if lower_bound is (negative OR nonpositive) AND upper_bound is > (positive OR nonnegative): > * lower_bound=0; //the interval includes zero > * lower_bound_type=closed; > * if( abs(lower_bound) > abs(upper_bound)){upper_bound = > abs(lower_bound)^exponent; upper_bound_type = lower_bound_type} > * if( abs(lower_bound) < abs(upper_bound)){upper_bound = > abs(upper_bound)^exponent; upper_bound_type = upper_bound_type} > * if( abs(lower_bound) = abs(upper_bound)){upper_bound = > abs(upper_bound)^exponent; upper_bound_type = Closing(lower_bound_type, > upper_bound_type) } > * if lower_bound is (nonnegative OR positive) AND upper_bound is > (nonnegative OR positive) > * lower_bound = lower_bound^exponent; > upper_bound=lower_bound^exponent; lower_bound_type=lower_bound_type; > upper_bound_type = upper_bound_type; > * if lower_bound is (negative OR nonpositive) AND upper_bound is > (negative OR nonpositive) > * lower_bound = abs(upper_bound)^exponent; > upper_bound=abs(lower_bound); Swap(lower_bound_type, upper_bound_type); > * if exponent is a symbol and a positive integer, (not a concrete > number), > * if lower_bound >= 1, optionally "flatten" even exponents to 2. > * if 0>=lower_bound>1, optionally "flatten" the lower bound to 0 > (large exponents will push the new lower_bound toward 0). > * > * if exponent is a nonnegative, even integer //now we have to worry > about 0^0 > * if anything is potentially zero (zero, nonnegative, nonpositive) > AND pedantic_flag : error "0^0" is undefined > * if lower_bound is negative and upper_bound is positive : > * lower_bound=0; //the interval includes zero > * lower_bound_type=closed; > * if( abs(lower_bound) > abs(upper_bound)){upper_bound = > abs(lower_bound)^exponent; upper_bound_type = lower_bound_type} > * if( abs(lower_bound) < abs(upper_bound)){upper_bound = > abs(upper_bound)^exponent; upper_bound_type = upper_bound_type} > * if( abs(lower_bound) = abs(upper_bound)){upper_bound = > abs(upper_bound)^exponent; upper_bound_type = Closing(lower_bound_type, > upper_bound_type) } > * if lower_bound and upper_bound are both positive > * lower_bound = lower_bound^exponent; > upper_bound=lower_bound^exponent; lower_bound_type=lower_bound_type; > upper_bound_type = upper_bound_type; > * if lower_bound and upper_bound are both negative > * lower_bound = abs(upper_bound)^exponent; > upper_bound=abs(lower_bound)^exponent; Swap(lower_bound_type, > upper_bound_type); > * if exponent is a symbol and a nonnegative integer, (not a concrete > number), optionally "flatten" exponent > * lower_bound = min(lower_bound, 1); upper_bound = max(1, > upper_bound) > * if lower_bound=1, lower_bound_type=closed; if upper_bound=1, > upper_bound_type = closed; > * > * if exponent is positive, odd (integer) > * lower_bound = lower_bound^exponent; upper_bound = > upper_bound^exponent; > * lower_bound_type = lower_bound_type; upper_bound_type = > upper_bound_type; > * if exponent is a symbol and a positive integer, (not a concrete > number), optionally "flatten" the exponent > * if lower_bound>=1, we may optionally replace the exponent with > 1. Large exponents will cause the bound to grow, so the current bound is > least. > * if 0 < lower_bound< 1, lower_bound=0, lower_bound_type=open. Large > exponents will shrink the bounds toward zero. > * if 1 < lower_bound< 0, we may optionally replace the exponent with > 1. Larger exponents will only cause the bound to grow towards zero, so the > current bound is least. > * if lower_bound<1, lower_bound=inf, lower_bound_type=open. > Larger exponents will only cause the bound to grow towards negative > infinity. > * if upper_bound<=1, we may optionally replace the exponent > with 1. Large exponents will cause the bound to grow more negative, so the > current bound is greatest. > * if 1 < upper_bound< 0, upper_bound=0, upper_bound_type=open. > Large exponents will cause the bound to grow toward zero. > * if 0 < upper_bound< 1, we may optionally replace the exponent > with 1. Large exponents will cause the bound to grow more negative, so the > current bound is greatest. > * if 1 < upper_bound , upper_bound=+inf, upper_bound_type=open. > Large exponents will cause the bound to grow towards infinity. > * > * if exponent is negative AND the base's interval includes zero AND > pedantic_flag : invalid > * if exponent is negative AND the base's interval includes zero AND NOT > pedantic_flag : split the interval, removing zero from it, and continue > * if exponent is even, negative integer AND the base's interval > excludes zero TODO > * if exponent is odd, negative integer AND the base's interval excludes > zero TODO > * if exponent is a symbol, even negative integer, optionally "flatten" > TODO > * if exponent is a symbol, odd negative integer, optionally "flatten" > TODO > * if exponent is zero and base nonzero : identically 1 > * if exponent is zero and base zero : invalid > * Add abs value support > * if lower bound is positive > nothing changes > * if lower bound is negative and upper bound is positive > [0,upper > bound] (upper bound type remains the same) > * if lower bound is negative and upper bound is negative > > ([upper_bound, lowerbound]) (flip the bounds basically) > * > * METHODS USED ABOVE > * Closing(lower_bound_type, upper_bound_type){ > if(lower_bound_type==closed){return closed} > if(upper_bound_type==closed){return closed} else {return open} } > * > */ > > > /* in C`esque pseudo code, altered in ways to make it more clear, > hopefully */ > > bool[6] determine_signs(expr){ /*Returns a list of Booleans: neg, > negzero, zero, poszero, positive, and unknown (unknown not required)*/ > /* Yes I know it is bad practice allocate memory within a method without > freeing that object in the same method */ > bool[] expression_signs = calloc( sizeof(int) ); /*allocating less than > an int can be inefficient, calloc zeros the memory*/ > unsigned int numnegs = 0; > > /* if this is a basecase, an atom */ > if( is_atom(expression) ){ > expressions_signs = assumption_lookup(atom); > } > > for(i=1; i<=max_parts; i++){ > bool[6] local_signs = determine_signs(part(expr,i)); > expression_signs = expression_signs OR local_signs; /* do for neg, > negzero, zero, poszero, positive, and unknown */ > if( local_signs::neg OR local_signs::negzero ){ numnegs= numnegs+1; } > free(local_signs); /* Yes I know it is bad practice allocate and free > memory this way */ > } > > /* if the expression was empty or invalid */ > if(NOT(expression_signs)){ /*If the entire zero'ed memory is still > zeroed */ > *expression_signs::unknown = 1; > return(expression_signs); > } > > /* if its addition */ > if part(expr, 0) = '+'{ > /* unknown or conflicting signs */ > if(expression_signs::unknown OR > (( expression_signs::neg OR expression_signs::negzero) AND > (expression_signs::pos OR expression_signs::poszero))){ > *expression_signs = 0; > *expression_signs::unknown = 1; > return(expression_signs); > } > /* Everything that follows assumes the signs are not unknown or > conflicting */ > > /* is anything strictly negative? If so then we can clear the zero and > negzero bits */ > if(expression_signs::neg){ > *expression_signs::zero = 0; > *expression_signs::negzero = 0; > } > > /* is anything strictly positive? If so then we can clear the zero and > poszero bits */ > if(expression_signs::neg){ > *expression_signs::zero = 0; > *expression_signs::poszero = 0; > } > } > > /* if its multiplication */ > If part(expr, 0) = '*'{ > /* unknown or conflicting signs */ > if(expression_signs::unknown){ > *expression_signs = 0; > *expression_signs::unknown = 1; > return(expression_signs); > } > /* If there is an even number of negative terms */ > if( is_even(numnegs) ){ > /* And if there are zeros of any sort > if( express_signs::negzero OR express_signs::zero OR > express_signs::poszero ){ > /* positive or zero */ > *express_signs = 0; > *express_signs::poszero = 1; > } > else{ /* no zeros were possible */ > /* positive */ > *express_signs = 0; > *express_signs::pos = 1; > } > } > /* If there is an odd number of negative terms */ > else { > /* And if there are zeros of any sort > if( express_signs::negzero OR express_signs::zero OR > express_signs::poszero ){ > /* negative or zero */ > *express_signs = 0; > *express_signs::negzero = 1; > } > else{ /* no zeros were possible */ > /* negative */ > *express_signs = 0; > *express_signs::neg = 1; > } > } > } > return(express_signs) > } > > > On Sat, May 2, 2015 at 11:13 PM, Mike Valenzuela <mickle.mouse@...> > wrote: > >> Oh another example of a Maxima not figuring out inequalities well: >> >> assume(a>=0, b>=0, a<=1, b<=1)$ >> assume(m>4)$ >> is(a1 <= 0); >> is(b*(a1) <= 0); >> is(b*2 <= 2); >> is(b*2  2 <= 0); >> is(b*(a1) + 2  2<=0); >> is(b*(a1) + (b*2  2) <=0); >> true >> true >> true >> true >> true >> unknown >> >> The last answer should be true, because the sum of any nonpositive terms >> is still nonpositive. Although I can find these cases, I am having trouble >> figuring out how Maxima should solve this kind of problem. At least for >> multiplication and addition I think this can be solved. >> >> I'm thinking about ways to improve Maxima's capabilities. >> >> >> On Sat, May 2, 2015 at 7:19 PM, Mike Valenzuela <mickle.mouse@...> >> wrote: >> >>> Hello again, >>> >>> Sorry for posting so many questions, but I've been trying to solve a >>> rather difficult problem and I'm taking several approaches. Anyways I've >>> found a few "issues" with inequality testing. >>> >>> (%i1) load(ineq)$ >>> (%i2) assume(a>=0, b>=0, a<=1, b<=1)$ >>> (%i3) is(a*b >= 0); >>> (%o3) true >>> (%i4) is(a*b <= 1); >>> (%o4) unknown >>> (%i5) is( 1(a*b) >= 0); >>> (%o5) unknown >>> (%i6) (a * b >=0), pred; >>> (%o6) true >>> (%i7) (a * b <=1), pred; >>> (%o7) a*b<=1 >>> I would expect that if a<=X and b<=Y, then a*b<=X*Y, but Maxima cannot >>> figure that out. Annoying but at least it is not giving a strictly wrong >>> answer. >>> >>> And someone else once complained about the following: >>> (%i8) declare(k, integer)$ >>> (%i9) assume(k>1)$ >>> (%i10) is(k^2>k); >>> (%o10) true >>> (%i11) is(k^2 + 1 > k); >>> (%o12) unknown >>> (%i12) k^2+1 > k, pred; >>> (%o12) k^2+1>k >>> Again, this is annoying, but not strictly wrong. Yes, we can figure it >>> out, but Maxima cannot. I can even think of cases where if (a>b) then not >>> a+1>b, but this requires working with modulus arithmetic or finite fields >>> or something like that. But in this case k was declared an integer. >>> >>> Is there some other package to expand Maxima's inequality testing? >>> >>> >> > > >  > One dashboard for servers and applications across PhysicalVirtualCloud > Widest outofthebox monitoring support with 50+ applications > Performance metrics, stats and reports that give you Actionable Insights > Deep dive visibility with transaction tracing using APM Insight. > http://ad.doubleclick.net/ddm/clk/290420510;117567292;y > _______________________________________________ > Maximadiscuss mailing list > Maximadiscuss@... > https://lists.sourceforge.net/lists/listinfo/maximadiscuss > > 
From: Stavros Macrakis (Σταῦρος Μακράκης) <macrakis@al...>  20150503 08:35:20

Mike, Yes, Maxima's inequality handling can certainly be improved in many ways. I would recommend that you *avoid* the ineq package. All it does is handle arithmetic on inequalities, e.g., (2<3)*x => 2*x<3*x (if x>=0). It adds no substantive functionality to inequality handling beyond what is(...) can already do — which as you point out, is limited. The best package I know for handling inequalities in Maxima is Barton Willis's to_poly_solve. The %solve function in it uses FourierMotzkin elimination to handle linear inequalities. The general nonlinear case is harder. Try it out. s On Sun, May 3, 2015 at 2:13 AM, Mike Valenzuela <mickle.mouse@...> wrote: > Oh another example of a Maxima not figuring out inequalities well: > > assume(a>=0, b>=0, a<=1, b<=1)$ > assume(m>4)$ > is(a1 <= 0); > is(b*(a1) <= 0); > is(b*2 <= 2); > is(b*2  2 <= 0); > is(b*(a1) + 2  2<=0); > is(b*(a1) + (b*2  2) <=0); > true > true > true > true > true > unknown > > The last answer should be true, because the sum of any nonpositive terms > is still nonpositive. Although I can find these cases, I am having trouble > figuring out how Maxima should solve this kind of problem. At least for > multiplication and addition I think this can be solved. > > I'm thinking about ways to improve Maxima's capabilities. > > > On Sat, May 2, 2015 at 7:19 PM, Mike Valenzuela <mickle.mouse@...> > wrote: > >> Hello again, >> >> Sorry for posting so many questions, but I've been trying to solve a >> rather difficult problem and I'm taking several approaches. Anyways I've >> found a few "issues" with inequality testing. >> >> (%i1) load(ineq)$ >> (%i2) assume(a>=0, b>=0, a<=1, b<=1)$ >> (%i3) is(a*b >= 0); >> (%o3) true >> (%i4) is(a*b <= 1); >> (%o4) unknown >> (%i5) is( 1(a*b) >= 0); >> (%o5) unknown >> (%i6) (a * b >=0), pred; >> (%o6) true >> (%i7) (a * b <=1), pred; >> (%o7) a*b<=1 >> I would expect that if a<=X and b<=Y, then a*b<=X*Y, but Maxima cannot >> figure that out. Annoying but at least it is not giving a strictly wrong >> answer. >> >> And someone else once complained about the following: >> (%i8) declare(k, integer)$ >> (%i9) assume(k>1)$ >> (%i10) is(k^2>k); >> (%o10) true >> (%i11) is(k^2 + 1 > k); >> (%o12) unknown >> (%i12) k^2+1 > k, pred; >> (%o12) k^2+1>k >> Again, this is annoying, but not strictly wrong. Yes, we can figure it >> out, but Maxima cannot. I can even think of cases where if (a>b) then not >> a+1>b, but this requires working with modulus arithmetic or finite fields >> or something like that. But in this case k was declared an integer. >> >> Is there some other package to expand Maxima's inequality testing? >> >> > > >  > One dashboard for servers and applications across PhysicalVirtualCloud > Widest outofthebox monitoring support with 50+ applications > Performance metrics, stats and reports that give you Actionable Insights > Deep dive visibility with transaction tracing using APM Insight. > http://ad.doubleclick.net/ddm/clk/290420510;117567292;y > _______________________________________________ > Maximadiscuss mailing list > Maximadiscuss@... > https://lists.sourceforge.net/lists/listinfo/maximadiscuss > > 
From: Mike Valenzuela <mickle.mouse@gm...>  20150503 08:31:23

Hello all again, I've been trying to put together a rule list for working with inequalities, especially for testing, so I put together some rules (they need double, triple, etc. checking). I got pretty tired so I don't even know if this mailing list will understand what I wrote. I suspect these rules can be vastly improved, probably compressed, and overall made more accurate and complete. This is sort of a work in progress and is not even ready for Maxima, so I haven't even moved this to git yet. I just do not want to invest anymore time into this project if someone already has a solution. If no one has a better solution for testing inequalities, then maybe the following text could be converted into test cases and eventually a lisp or Maxima routine can be written. I release the following mistake ridden ramblings of a tired crazy person under the GPL3 license. (I don't even know if I have to say as much). /* Revisions to do: */ /* * * To extend the following to multiple intervals, perform it on each interval one at a time * * Unless stated bounds are (inf,inf) * * pedantic_flag = true by default, but may be set to false to allow 0^0 = 1. * * TODO Add power support * what if lower_bound=upper_bound? Should we error on (4,4] and [4,4) or treat it as [4,4]? * * Note all power laws here assume lower_bound and upper_bound refer to the base's lower and upper bounds * if exponent is a positive, even integer * if lower_bound is (negative OR nonpositive) AND upper_bound is (positive OR nonnegative): * lower_bound=0; //the interval includes zero * lower_bound_type=closed; * if( abs(lower_bound) > abs(upper_bound)){upper_bound = abs(lower_bound)^exponent; upper_bound_type = lower_bound_type} * if( abs(lower_bound) < abs(upper_bound)){upper_bound = abs(upper_bound)^exponent; upper_bound_type = upper_bound_type} * if( abs(lower_bound) = abs(upper_bound)){upper_bound = abs(upper_bound)^exponent; upper_bound_type = Closing(lower_bound_type, upper_bound_type) } * if lower_bound is (nonnegative OR positive) AND upper_bound is (nonnegative OR positive) * lower_bound = lower_bound^exponent; upper_bound=lower_bound^exponent; lower_bound_type=lower_bound_type; upper_bound_type = upper_bound_type; * if lower_bound is (negative OR nonpositive) AND upper_bound is (negative OR nonpositive) * lower_bound = abs(upper_bound)^exponent; upper_bound=abs(lower_bound); Swap(lower_bound_type, upper_bound_type); * if exponent is a symbol and a positive integer, (not a concrete number), * if lower_bound >= 1, optionally "flatten" even exponents to 2. * if 0>=lower_bound>1, optionally "flatten" the lower bound to 0 (large exponents will push the new lower_bound toward 0). * * if exponent is a nonnegative, even integer //now we have to worry about 0^0 * if anything is potentially zero (zero, nonnegative, nonpositive) AND pedantic_flag : error "0^0" is undefined * if lower_bound is negative and upper_bound is positive : * lower_bound=0; //the interval includes zero * lower_bound_type=closed; * if( abs(lower_bound) > abs(upper_bound)){upper_bound = abs(lower_bound)^exponent; upper_bound_type = lower_bound_type} * if( abs(lower_bound) < abs(upper_bound)){upper_bound = abs(upper_bound)^exponent; upper_bound_type = upper_bound_type} * if( abs(lower_bound) = abs(upper_bound)){upper_bound = abs(upper_bound)^exponent; upper_bound_type = Closing(lower_bound_type, upper_bound_type) } * if lower_bound and upper_bound are both positive * lower_bound = lower_bound^exponent; upper_bound=lower_bound^exponent; lower_bound_type=lower_bound_type; upper_bound_type = upper_bound_type; * if lower_bound and upper_bound are both negative * lower_bound = abs(upper_bound)^exponent; upper_bound=abs(lower_bound)^exponent; Swap(lower_bound_type, upper_bound_type); * if exponent is a symbol and a nonnegative integer, (not a concrete number), optionally "flatten" exponent * lower_bound = min(lower_bound, 1); upper_bound = max(1, upper_bound) * if lower_bound=1, lower_bound_type=closed; if upper_bound=1, upper_bound_type = closed; * * if exponent is positive, odd (integer) * lower_bound = lower_bound^exponent; upper_bound = upper_bound^exponent; * lower_bound_type = lower_bound_type; upper_bound_type = upper_bound_type; * if exponent is a symbol and a positive integer, (not a concrete number), optionally "flatten" the exponent * if lower_bound>=1, we may optionally replace the exponent with 1. Large exponents will cause the bound to grow, so the current bound is least. * if 0 < lower_bound< 1, lower_bound=0, lower_bound_type=open. Large exponents will shrink the bounds toward zero. * if 1 < lower_bound< 0, we may optionally replace the exponent with 1. Larger exponents will only cause the bound to grow towards zero, so the current bound is least. * if lower_bound<1, lower_bound=inf, lower_bound_type=open. Larger exponents will only cause the bound to grow towards negative infinity. * if upper_bound<=1, we may optionally replace the exponent with 1. Large exponents will cause the bound to grow more negative, so the current bound is greatest. * if 1 < upper_bound< 0, upper_bound=0, upper_bound_type=open. Large exponents will cause the bound to grow toward zero. * if 0 < upper_bound< 1, we may optionally replace the exponent with 1. Large exponents will cause the bound to grow more negative, so the current bound is greatest. * if 1 < upper_bound , upper_bound=+inf, upper_bound_type=open. Large exponents will cause the bound to grow towards infinity. * * if exponent is negative AND the base's interval includes zero AND pedantic_flag : invalid * if exponent is negative AND the base's interval includes zero AND NOT pedantic_flag : split the interval, removing zero from it, and continue * if exponent is even, negative integer AND the base's interval excludes zero TODO * if exponent is odd, negative integer AND the base's interval excludes zero TODO * if exponent is a symbol, even negative integer, optionally "flatten" TODO * if exponent is a symbol, odd negative integer, optionally "flatten" TODO * if exponent is zero and base nonzero : identically 1 * if exponent is zero and base zero : invalid * Add abs value support * if lower bound is positive > nothing changes * if lower bound is negative and upper bound is positive > [0,upper bound] (upper bound type remains the same) * if lower bound is negative and upper bound is negative > ([upper_bound, lowerbound]) (flip the bounds basically) * * METHODS USED ABOVE * Closing(lower_bound_type, upper_bound_type){ if(lower_bound_type==closed){return closed} if(upper_bound_type==closed){return closed} else {return open} } * */ /* in C`esque pseudo code, altered in ways to make it more clear, hopefully */ bool[6] determine_signs(expr){ /*Returns a list of Booleans: neg, negzero, zero, poszero, positive, and unknown (unknown not required)*/ /* Yes I know it is bad practice allocate memory within a method without freeing that object in the same method */ bool[] expression_signs = calloc( sizeof(int) ); /*allocating less than an int can be inefficient, calloc zeros the memory*/ unsigned int numnegs = 0; /* if this is a basecase, an atom */ if( is_atom(expression) ){ expressions_signs = assumption_lookup(atom); } for(i=1; i<=max_parts; i++){ bool[6] local_signs = determine_signs(part(expr,i)); expression_signs = expression_signs OR local_signs; /* do for neg, negzero, zero, poszero, positive, and unknown */ if( local_signs::neg OR local_signs::negzero ){ numnegs= numnegs+1; } free(local_signs); /* Yes I know it is bad practice allocate and free memory this way */ } /* if the expression was empty or invalid */ if(NOT(expression_signs)){ /*If the entire zero'ed memory is still zeroed */ *expression_signs::unknown = 1; return(expression_signs); } /* if its addition */ if part(expr, 0) = '+'{ /* unknown or conflicting signs */ if(expression_signs::unknown OR (( expression_signs::neg OR expression_signs::negzero) AND (expression_signs::pos OR expression_signs::poszero))){ *expression_signs = 0; *expression_signs::unknown = 1; return(expression_signs); } /* Everything that follows assumes the signs are not unknown or conflicting */ /* is anything strictly negative? If so then we can clear the zero and negzero bits */ if(expression_signs::neg){ *expression_signs::zero = 0; *expression_signs::negzero = 0; } /* is anything strictly positive? If so then we can clear the zero and poszero bits */ if(expression_signs::neg){ *expression_signs::zero = 0; *expression_signs::poszero = 0; } } /* if its multiplication */ If part(expr, 0) = '*'{ /* unknown or conflicting signs */ if(expression_signs::unknown){ *expression_signs = 0; *expression_signs::unknown = 1; return(expression_signs); } /* If there is an even number of negative terms */ if( is_even(numnegs) ){ /* And if there are zeros of any sort if( express_signs::negzero OR express_signs::zero OR express_signs::poszero ){ /* positive or zero */ *express_signs = 0; *express_signs::poszero = 1; } else{ /* no zeros were possible */ /* positive */ *express_signs = 0; *express_signs::pos = 1; } } /* If there is an odd number of negative terms */ else { /* And if there are zeros of any sort if( express_signs::negzero OR express_signs::zero OR express_signs::poszero ){ /* negative or zero */ *express_signs = 0; *express_signs::negzero = 1; } else{ /* no zeros were possible */ /* negative */ *express_signs = 0; *express_signs::neg = 1; } } } return(express_signs) } On Sat, May 2, 2015 at 11:13 PM, Mike Valenzuela <mickle.mouse@...> wrote: > Oh another example of a Maxima not figuring out inequalities well: > > assume(a>=0, b>=0, a<=1, b<=1)$ > assume(m>4)$ > is(a1 <= 0); > is(b*(a1) <= 0); > is(b*2 <= 2); > is(b*2  2 <= 0); > is(b*(a1) + 2  2<=0); > is(b*(a1) + (b*2  2) <=0); > true > true > true > true > true > unknown > > The last answer should be true, because the sum of any nonpositive terms > is still nonpositive. Although I can find these cases, I am having trouble > figuring out how Maxima should solve this kind of problem. At least for > multiplication and addition I think this can be solved. > > I'm thinking about ways to improve Maxima's capabilities. > > > On Sat, May 2, 2015 at 7:19 PM, Mike Valenzuela <mickle.mouse@...> > wrote: > >> Hello again, >> >> Sorry for posting so many questions, but I've been trying to solve a >> rather difficult problem and I'm taking several approaches. Anyways I've >> found a few "issues" with inequality testing. >> >> (%i1) load(ineq)$ >> (%i2) assume(a>=0, b>=0, a<=1, b<=1)$ >> (%i3) is(a*b >= 0); >> (%o3) true >> (%i4) is(a*b <= 1); >> (%o4) unknown >> (%i5) is( 1(a*b) >= 0); >> (%o5) unknown >> (%i6) (a * b >=0), pred; >> (%o6) true >> (%i7) (a * b <=1), pred; >> (%o7) a*b<=1 >> I would expect that if a<=X and b<=Y, then a*b<=X*Y, but Maxima cannot >> figure that out. Annoying but at least it is not giving a strictly wrong >> answer. >> >> And someone else once complained about the following: >> (%i8) declare(k, integer)$ >> (%i9) assume(k>1)$ >> (%i10) is(k^2>k); >> (%o10) true >> (%i11) is(k^2 + 1 > k); >> (%o12) unknown >> (%i12) k^2+1 > k, pred; >> (%o12) k^2+1>k >> Again, this is annoying, but not strictly wrong. Yes, we can figure it >> out, but Maxima cannot. I can even think of cases where if (a>b) then not >> a+1>b, but this requires working with modulus arithmetic or finite fields >> or something like that. But in this case k was declared an integer. >> >> Is there some other package to expand Maxima's inequality testing? >> >> > 
From: Mike Valenzuela <mickle.mouse@gm...>  20150503 06:13:55

Oh another example of a Maxima not figuring out inequalities well: assume(a>=0, b>=0, a<=1, b<=1)$ assume(m>4)$ is(a1 <= 0); is(b*(a1) <= 0); is(b*2 <= 2); is(b*2  2 <= 0); is(b*(a1) + 2  2<=0); is(b*(a1) + (b*2  2) <=0); true true true true true unknown The last answer should be true, because the sum of any nonpositive terms is still nonpositive. Although I can find these cases, I am having trouble figuring out how Maxima should solve this kind of problem. At least for multiplication and addition I think this can be solved. I'm thinking about ways to improve Maxima's capabilities. On Sat, May 2, 2015 at 7:19 PM, Mike Valenzuela <mickle.mouse@...> wrote: > Hello again, > > Sorry for posting so many questions, but I've been trying to solve a > rather difficult problem and I'm taking several approaches. Anyways I've > found a few "issues" with inequality testing. > > (%i1) load(ineq)$ > (%i2) assume(a>=0, b>=0, a<=1, b<=1)$ > (%i3) is(a*b >= 0); > (%o3) true > (%i4) is(a*b <= 1); > (%o4) unknown > (%i5) is( 1(a*b) >= 0); > (%o5) unknown > (%i6) (a * b >=0), pred; > (%o6) true > (%i7) (a * b <=1), pred; > (%o7) a*b<=1 > I would expect that if a<=X and b<=Y, then a*b<=X*Y, but Maxima cannot > figure that out. Annoying but at least it is not giving a strictly wrong > answer. > > And someone else once complained about the following: > (%i8) declare(k, integer)$ > (%i9) assume(k>1)$ > (%i10) is(k^2>k); > (%o10) true > (%i11) is(k^2 + 1 > k); > (%o12) unknown > (%i12) k^2+1 > k, pred; > (%o12) k^2+1>k > Again, this is annoying, but not strictly wrong. Yes, we can figure it > out, but Maxima cannot. I can even think of cases where if (a>b) then not > a+1>b, but this requires working with modulus arithmetic or finite fields > or something like that. But in this case k was declared an integer. > > Is there some other package to expand Maxima's inequality testing? > > 
From: Ronald Modesitt <ronald.835@gm...>  20150503 03:28:01

Professor Woollett & Jamie, I tried all your examples again professor, with the same results as before beginning with [%i4] on both Xmaxima and wxMaxima. Jamie's approach works on both wxMaxima and Xmaxima interfaces. Do you suppose this represents the inherent differences between Windows XP (32) and Linux (64) execution? Thanks again, Ron 
From: Mike Valenzuela <mickle.mouse@gm...>  20150503 02:19:36

Hello again, Sorry for posting so many questions, but I've been trying to solve a rather difficult problem and I'm taking several approaches. Anyways I've found a few "issues" with inequality testing. (%i1) load(ineq)$ (%i2) assume(a>=0, b>=0, a<=1, b<=1)$ (%i3) is(a*b >= 0); (%o3) true (%i4) is(a*b <= 1); (%o4) unknown (%i5) is( 1(a*b) >= 0); (%o5) unknown (%i6) (a * b >=0), pred; (%o6) true (%i7) (a * b <=1), pred; (%o7) a*b<=1 I would expect that if a<=X and b<=Y, then a*b<=X*Y, but Maxima cannot figure that out. Annoying but at least it is not giving a strictly wrong answer. And someone else once complained about the following: (%i8) declare(k, integer)$ (%i9) assume(k>1)$ (%i10) is(k^2>k); (%o10) true (%i11) is(k^2 + 1 > k); (%o12) unknown (%i12) k^2+1 > k, pred; (%o12) k^2+1>k Again, this is annoying, but not strictly wrong. Yes, we can figure it out, but Maxima cannot. I can even think of cases where if (a>b) then not a+1>b, but this requires working with modulus arithmetic or finite fields or something like that. But in this case k was declared an integer. Is there some other package to expand Maxima's inequality testing? 
From: Jaime Villate <villate@fe...>  20150502 22:52:08

On 02052015 17:32, Ronald Modesitt wrote: > The following plot statement from the mbe2plotfit tutorial, in wxMaxima > > plot2d ([uˆ3,[parametric, cos(t), sin(t), [’t,%pi,%pi]]], > [’u,1.1,1.1],[’x,1.5,1.5],[’y,1.5,1.5], > [gnuplot_preamble,"set size ratio 1;"])$ > > gives the error message: > > plotoptionsparser: unknown plot option: [u, 1.1,1.1] Hi, I do not know if that command ever worked in older versions, but in the more recent versions, in order to get what you want, you would have to use: plot2d([x^3,[parametric,cos(t),sin(t),[t,%pi,%pi]]], [x,1.5,1.5],[y,1.5,1.5],same_xy)$ If the purpose of using u and x was to show the horizontal axis from 1.5 to 1.5 but to plot u^3 only from 1.1 to 1.1, I think that has never been possible with plot2d. Regards, Jaime 
From: Mike Valenzuela <mickle.mouse@gm...>  20150502 22:00:39

Hello all, I realize there are already a number of ways to perform simplification and often times you have to tell Maxima what you want in order for it to provide that kind of simplification. I've been working with expressions which are symmetric in variables specified by the user (*i.e.,* f(x,y,z) = f(y,z,x)). I am looking for simplified forms which "Look" symmetric. I have a motivating example and the steps I used to manually get it there. (%i1) expr1: diff(1  (1  V1(v[1])*V2(v[2]))^(m),v[1],1,v[2],1); (%i2) expr2: (m)*diff(V1(v[1]),v[1])*diff(V2(v[2]),v[2])*(1  V1(v[1])*V2(v[2]))^(m2) * multthru(expr1 /( (m)*diff(V1(v[1]),v[1])*diff(V2(v[2]),v[2])*(1  V1(v[1])*V2(v[2]))^(m2) ) ); (%i3) substpart( radcan(part(expr2,4)), expr2, 4); (%o1) (1V1(v[1])*V2(v[2]))^m1*('diff(V1(v[1])))*('diff(V2(v[2])))*mV1(v[1])*V2(v[2])*(1V1(v[1])*V2(v[2]))^m2*('diff(V1(v[1])))*('diff(V2(v[2])))*(m1)*m (%o2) (1V1(v[1])*V2(v[2]))^m2*('diff(V1(v[1])))*('diff(V2(v[2])))*(V1(v[1])*V2(v[2])*(m1)V1(v[1])*V2(v[2])+1)*m (%o3) (1V1(v[1])*V2(v[2]))^m2*('diff(V1(v[1])))*('diff(V2(v[2])))*m*(1V1(v[1])*V2(v[2])*m) I am not sure if I can make (%o3) any more ``obvious,'' but I like its output enough. Radcan kind of works, except it fails to factor as much and produces a denominator: (%i4) radcan(expr1); (%o5) (V1(v[1])*V2(v[2])*(1V1(v[1])*V2(v[2]))^m*('diff(V1(v[1])))*('diff(V2(v[2])))*m^2(1V1(v[1])*V2(v[2]))^m*('diff(V1(v[1])))*('diff(V2(v[2])))*m)/(V1(v[1])^2*V2(v[2])^22*V1(v[1])*V2(v[2])+1) So I guess I have a few questions. (1A) Is there a simplify command which can do steps 13 in a more automatic sense? I imagine if the command exists, it would look like symsimp(expr, [set of symmetric variables]) which simplifies ensuring symmetry.By ensuring symmetry, I mean either a subexpression is part of a symmetric expression or is symmetric itself. Special care would be needed for symmetric functions. For example the expression (1f(x))*(1f(y))*(x*y) + Q(x,y), would be symmetric if Q(x,y) is a symmetric function. I suppose this could be extended to include multiple sets of symmetric variables/expressions *e.g.*, symsimp(expr, [x,1/y], [y, 1/x]). (1B) If this does not exist, how much work would it be to create such a command? (1C) If it does not exist, how much interest would the Maxima community have in such a command? (2) Is there a way to tell Maxima, in general, that certain forms are desired? I've encountered similar problems where, rather than needing symmetry, wanted things in terms of sums or differences of variables. I kind of fear that "desired forms" cannot be implemented without some sort of graph search. A graph search algorithm (e.g., IDA* search), even with a good heuristic, is slow compared to rulebased systems. Just in case anyone thinks it is a good idea, I found an IDA* kernel here ( http://aima.cs.berkeley.edu/lisp/search/algorithms/ida.lisp). (3) Is there a way to tell radcan, ratsimp, etc. to not create a denominator if an exponent is known to be positive? Currently (%i6) assume(a>1)$ (%i7) radcan((1+y)*x^(a1)); (%o7) (x^a*y+x^a)/x But I am looking for something like radcan((1+y)*x^(a1)) > (1+y)*x^(a1), when a has been assumed to be strictly larger than 1. Thank you in advance to any and all replies. 
From: edgar <edgarrft@we...>  20150502 19:47:40

Hi maxima list, >> From: Ronald Modesitt >> Sent: Saturday, May 02, 2015 9:32 AM >> To: maximadiscuss@... >> Subject: [Maximadiscuss] Plot2d parametric plot errors from >> mb2eplotfit >> >> System Configuration: >> >> Linux Mint 17.1, >> >> Dell Precision 690, 8 Gb >> >> Maxima Configuration: >> >> wxMaxima version 13.04.2 >> >> Maxima version: 5.32.1 >> myoptions: [maxima_userdir, stardisp, float, numer, display2d, >> %edispflag, exptdispflag, fpprintprec, leftjust] >> >> The following plot statement from the mbe2plotfit tutorial, in >> wxMaxima >> >> plot2d ([uˆ3,[parametric, cos(t), sin(t), [’t,%pi,%pi]]], >> [’u,1.1,1.1],[’x,1.5,1.5],[’y,1.5,1.5], >> [gnuplot_preamble,"set size ratio 1;"])$ >> >> gives the error message: >> >> plotoptionsparser: unknown plot option: [u, 1.1,1.1] >> >> Xmaxima gives the same result. >> >> Parametric plot examples from Maxima book all work. >> >> I would appreciate a review by someone to help me find my error. >> >> Thanks in advance. >> >> Ron >> >> Ronald F. Modesitt >> 1215 Ptarmigan Dr. >> Longmont, CO 80504 >> 3034853887 >> > > Am Sat, 2 May 2015 12:17:11 0700 > schrieb "Edwin Woollett" <woollett@...>: > > On my windows xp box, with gcl binary 5.31.2, I have no problems. > Here are a series of test examples I ran with no problems as you > describe: ========================================================== > > Maxima 5.31.2 http://maxima.sourceforge.net > using Lisp GNU Common Lisp (GCL) GCL 2.6.8 (a.k.a. GCL) > Distributed under the GNU Public License. See the file COPYING. > Dedicated to the memory of William Schelter. > The function bug_report() provides bug reporting information. > "20150502" >  > with display2d:false in all the following, > > (%i1) plot2d(u^3,['u,1.1,1.1],['x,1.5,1.5],['y,1.5,1.5])$ > > (%i2) plot2d([parametric,cos(t),sin(t),['t,%pi,%pi]], > ['x,1.5,1.5],['y,1.5,1.5])$ > > (%i3) plot2d([parametric,cos(t),sin(t),['t,%pi,%pi]], > ['x,1.5,1.5],['y,1.5,1.5], > [gnuplot_preamble,"set size ratio 1"])$ > > (%i4) plot2d( [ u^3, [parametric,cos(t),sin(t), ['t,%pi,%pi] ] ], > ['u,1.1,1.1],['x,1.5,1.5],['y,1.5,1.5])$ > > (%i5) plot2d( [ u^3, [parametric,cos(t),sin(t), ['t,%pi,%pi] ] ], > ['u,1.1,1.1],['x,1.5,1.5],['y,1.5,1.5], > [gnuplot_preamble,"set size ratio 1"])$ > > (%i6) plot2d( [ u^3, [parametric,cos(t),sin(t), ['t,%pi,%pi] ] ], > ['u,1.1,1.1],['x,1.5,1.5],['y,1.5,1.5], > [gnuplot_preamble,"set size ratio 1;"])$ > > here is my build info: >  > (%i8) build_info(); > (%o8) ?%build_info("5.31.2","20131007 23:05:06","i686pcmingw32", > "GNU Common Lisp (GCL)","GCL 2.6.8") > (%i9) display2d:true$ > (%i10) build_info(); > (%o10) > Maxima version: "5.31.2" > Maxima build date: "20131007 23:05:06" > Host type: "i686pcmingw32" > Lisp implementation type: "GNU Common Lisp (GCL)" > Lisp implementation version: "GCL 2.6.8" > ============================================ > > Ted In case it helps to find the problem: On Debian Linux, Ted's examples (%i4), (%i5), and (%i4) all produce the same error: plotoptionsparser: unknown plot option: [u,1.1,1.1]  an error. To debug this try: debugmode(true); If I set debugmode(true); and type :bt in the debugger I don't get a backtrace. :( Maybe this is something Linux or nonWindows specific. My build_info: (%i7) build_info(); (%o7) Maxima version: "5.35.1" Maxima build date: "20150207 10:27:10" Host type: "x86_64unknownlinuxgnu" Lisp implementation type: "SBCL" Lisp implementation version: "1.2.8" I'm using gnuplot 4.6 patchlevel 0  edgar  The author of this email does not necessarily endorse the following advertisements, which are the sole responsibility of the advertiser: 
From: Albrecht, Helmut <Helmut.A<lbrecht@ph...>  20150502 19:25:06

Hello again, first of all, I will pay tribute to you and your work in developing and maintaining maxima. The most important reasons for choosing maxima at our university: It is open source and free of charge (students normally only have a little money) and it is available for Windows and OS X. Unfortunately the most recent downloadversion for OS X dates back to April 2013, while the WindowsVersion has been updated much more frequently. Is there a special reason for neglecting OS X in the past two years? Of course I tried the "homebrew"installation as recommended on the wxMaximaHomepage. I succeeded in installing maxima 5.34.1 but I failed in installing wxMaxima, because I got only wxmaxima version 13.4.2, which dates back to 2013. Please keep in mind that most people buying and using a Mac are only users  and no UNIXexperts. I would appreciate your answer in this matter. Best regards Helmut Albrecht ************************************* Prof. Dr. Helmut Albrecht Institut für Mathematik Pädagogische Hochschule 73525 Schwäbisch Gmünd 07171983455 (fon) 07171983370 (fax) PS: Wollten Sie schon immer wissen, warum Elefanten dicke Beine haben? http://www.amazon.de/WarumElefantendickeBeinehaben/dp/3833496932 
From: Edwin Woollett <woollett@ch...>  20150502 19:19:54

in the interests of “full disclosure”, I should say that I was using (as always) XMaxima! Ted From: Ronald Modesitt Sent: Saturday, May 02, 2015 9:32 AM To: maximadiscuss@... Subject: [Maximadiscuss] Plot2d parametric plot errors from mb2eplotfit System Configuration: Linux Mint 17.1, Dell Precision 690, 8 Gb Maxima Configuration: wxMaxima version 13.04.2 Maxima version: 5.32.1 myoptions: [maxima_userdir, stardisp, float, numer, display2d, %edispflag, exptdispflag, fpprintprec, leftjust] The following plot statement from the mbe2plotfit tutorial, in wxMaxima plot2d ([uˆ3,[parametric, cos(t), sin(t), [’t,%pi,%pi]]], [’u,1.1,1.1],[’x,1.5,1.5],[’y,1.5,1.5], [gnuplot_preamble,"set size ratio 1;"])$ gives the error message: plotoptionsparser: unknown plot option: [u, 1.1,1.1] Xmaxima gives the same result. Parametric plot examples from Maxima book all work. I would appreciate a review by someone to help me find my error. Thanks in advance. Ron Ronald F. Modesitt 1215 Ptarmigan Dr. Longmont, CO 80504 3034853887   One dashboard for servers and applications across PhysicalVirtualCloud Widest outofthebox monitoring support with 50+ applications Performance metrics, stats and reports that give you Actionable Insights Deep dive visibility with transaction tracing using APM Insight. http://ad.doubleclick.net/ddm/clk/290420510;117567292;y  _______________________________________________ Maximadiscuss mailing list Maximadiscuss@... https://lists.sourceforge.net/lists/listinfo/maximadiscuss 
From: Edwin Woollett <woollett@ch...>  20150502 19:17:11

Hi Ron, On my windows xp box, with gcl binary 5.31.2, I have no problems. Here are a series of test examples I ran with no problems as you describe: ========================================================== Maxima 5.31.2 http://maxima.sourceforge.net using Lisp GNU Common Lisp (GCL) GCL 2.6.8 (a.k.a. GCL) Distributed under the GNU Public License. See the file COPYING. Dedicated to the memory of William Schelter. The function bug_report() provides bug reporting information. "20150502"  with display2d:false in all the following, (%i1) plot2d(u^3,['u,1.1,1.1],['x,1.5,1.5],['y,1.5,1.5])$ (%i2) plot2d([parametric,cos(t),sin(t),['t,%pi,%pi]], ['x,1.5,1.5],['y,1.5,1.5])$ (%i3) plot2d([parametric,cos(t),sin(t),['t,%pi,%pi]], ['x,1.5,1.5],['y,1.5,1.5], [gnuplot_preamble,"set size ratio 1"])$ (%i4) plot2d( [ u^3, [parametric,cos(t),sin(t), ['t,%pi,%pi] ] ], ['u,1.1,1.1],['x,1.5,1.5],['y,1.5,1.5])$ (%i5) plot2d( [ u^3, [parametric,cos(t),sin(t), ['t,%pi,%pi] ] ], ['u,1.1,1.1],['x,1.5,1.5],['y,1.5,1.5], [gnuplot_preamble,"set size ratio 1"])$ (%i6) plot2d( [ u^3, [parametric,cos(t),sin(t), ['t,%pi,%pi] ] ], ['u,1.1,1.1],['x,1.5,1.5],['y,1.5,1.5], [gnuplot_preamble,"set size ratio 1;"])$ here is my build info:  (%i8) build_info(); (%o8) ?%build_info("5.31.2","20131007 23:05:06","i686pcmingw32", "GNU Common Lisp (GCL)","GCL 2.6.8") (%i9) display2d:true$ (%i10) build_info(); (%o10) Maxima version: "5.31.2" Maxima build date: "20131007 23:05:06" Host type: "i686pcmingw32" Lisp implementation type: "GNU Common Lisp (GCL)" Lisp implementation version: "GCL 2.6.8" ============================================ Ted From: Ronald Modesitt Sent: Saturday, May 02, 2015 9:32 AM To: maximadiscuss@... Subject: [Maximadiscuss] Plot2d parametric plot errors from mb2eplotfit System Configuration: Linux Mint 17.1, Dell Precision 690, 8 Gb Maxima Configuration: wxMaxima version 13.04.2 Maxima version: 5.32.1 myoptions: [maxima_userdir, stardisp, float, numer, display2d, %edispflag, exptdispflag, fpprintprec, leftjust] The following plot statement from the mbe2plotfit tutorial, in wxMaxima plot2d ([uˆ3,[parametric, cos(t), sin(t), [’t,%pi,%pi]]], [’u,1.1,1.1],[’x,1.5,1.5],[’y,1.5,1.5], [gnuplot_preamble,"set size ratio 1;"])$ gives the error message: plotoptionsparser: unknown plot option: [u, 1.1,1.1] Xmaxima gives the same result. Parametric plot examples from Maxima book all work. I would appreciate a review by someone to help me find my error. Thanks in advance. Ron Ronald F. Modesitt 1215 Ptarmigan Dr. Longmont, CO 80504 3034853887   One dashboard for servers and applications across PhysicalVirtualCloud Widest outofthebox monitoring support with 50+ applications Performance metrics, stats and reports that give you Actionable Insights Deep dive visibility with transaction tracing using APM Insight. http://ad.doubleclick.net/ddm/clk/290420510;117567292;y  _______________________________________________ Maximadiscuss mailing list Maximadiscuss@... https://lists.sourceforge.net/lists/listinfo/maximadiscuss 
From: Ronald Modesitt <ronald.835@gm...>  20150502 16:32:30

System Configuration: Linux Mint 17.1, Dell Precision 690, 8 Gb Maxima Configuration: wxMaxima version 13.04.2 Maxima version: 5.32.1 myoptions: [maxima_userdir, stardisp, float, numer, display2d, %edispflag, exptdispflag, fpprintprec, leftjust] The following plot statement from the mbe2plotfit tutorial, in wxMaxima plot2d ([uˆ3,[parametric, cos(t), sin(t), [’t,%pi,%pi]]], [’u,1.1,1.1],[’x,1.5,1.5],[’y,1.5,1.5], [gnuplot_preamble,"set size ratio 1;"])$ gives the error message: plotoptionsparser: unknown plot option: [u, 1.1,1.1] Xmaxima gives the same result. Parametric plot examples from Maxima book all work. I would appreciate a review by someone to help me find my error. Thanks in advance. Ron Ronald F. Modesitt 1215 Ptarmigan Dr. Longmont, CO 80504 3034853887 
From: Andrej Vodopivec <andrej.vodopivec@gm...>  20150502 07:42:08

I have uploaded windows binaries compiled with sbcl and ccl. Andrej On Fri, May 1, 2015 at 2:19 AM, Robert Dodier <robert.dodier@...> wrote: > I've tagged 5.36.1 in Git and built rpms and tar.gz and uploaded them to > the Sourceforge file manager. http://sourceforge.net/p/maxima/files > > This release includes a few commits, including 034005b1 which fixes a > problem with wxMaxima. > > If someone can build a Windows installer, that will be terrific. > > best > > Robert Dodier > > >  > One dashboard for servers and applications across PhysicalVirtualCloud > Widest outofthebox monitoring support with 50+ applications > Performance metrics, stats and reports that give you Actionable Insights > Deep dive visibility with transaction tracing using APM Insight. > http://ad.doubleclick.net/ddm/clk/290420510;117567292;y > _______________________________________________ > Maximadiscuss mailing list > Maximadiscuss@... > https://lists.sourceforge.net/lists/listinfo/maximadiscuss 
From: Robert Dodier <robert.dodier@gm...>  20150501 18:08:52

On 20150501, Gunter Königsmann <gunter@...> wrote: > I would opt for uploading this installer to the "downloads" section of > sourceforge.net  or for making Wolfgang a official developer so he can > do it. I agree that's a good idea. I think I enabled permission for you (peterpall) to upload files to the file manager, so you can do it if you wish. I'll put Wolfgang on the list of developers too if he wishes  he just has to tell us his Sourceforge user id. best, Robert Dodier 
From: Gunter Königsmann <gunter@pe...>  20150501 15:26:38

I would opt for uploading this installer to the "downloads" section of sourceforge.net  or for making Wolfgang a official developer so he can do it. Kind regards, Gunter. On Fr, Mai 1, 2015 at 3:43 , Wolfgang Dautermann <wolfgang@...> wrote: > On 01.05.2015 02:19, Robert Dodier wrote: >> If someone can build a Windows installer, that will be terrific. > > A (crosscompiled, Clispbased) installer is available at: > http://wolfgang.dautermann.at/maxima/ > > Best regards, Wolfgang > >  > One dashboard for servers and applications across > PhysicalVirtualCloud > Widest outofthebox monitoring support with 50+ applications > Performance metrics, stats and reports that give you Actionable > Insights > Deep dive visibility with transaction tracing using APM Insight. > http://ad.doubleclick.net/ddm/clk/290420510;117567292;y > _______________________________________________ > Maximadiscuss mailing list > Maximadiscuss@... > https://lists.sourceforge.net/lists/listinfo/maximadiscuss 
From: Wolfgang Dautermann <wolfgang@da...>  20150501 13:44:07

On 01.05.2015 02:19, Robert Dodier wrote: > If someone can build a Windows installer, that will be terrific. A (crosscompiled, Clispbased) installer is available at: http://wolfgang.dautermann.at/maxima/ Best regards, Wolfgang 
From: Robert Dodier <robert.dodier@gm...>  20150501 00:19:54

I've tagged 5.36.1 in Git and built rpms and tar.gz and uploaded them to the Sourceforge file manager. http://sourceforge.net/p/maxima/files This release includes a few commits, including 034005b1 which fixes a problem with wxMaxima. If someone can build a Windows installer, that will be terrific. best Robert Dodier 
From: Stavros Macrakis (Σταῦρος Μακράκης) <macrakis@al...>  20150430 22:41:00

The abs case looks like a bug (please file it), sorry. On Thu, Apr 30, 2015 at 5:57 PM, Nijso Beishuizen <nijso@...> wrote: > Dear all, > > I have the following expression (the solution of Kamke ODE 1.63): > > res:(sqrt(x+1)*'integrate(abs(sqrt(y+1)+y)/(y^2+1),y)2)/sqrt(x+1)+%c; > > I try to see if it can be written explicitly in y: > > solve(res,y); > [] > > I don't know why this returns empty. Without abs(), it gives me > res:(sqrt(x+1)*'integrate((sqrt(y+1)+y)/(y^2+1),y)2)/sqrt(x+1)+%c; > grind(solve(res,y)); > ['integrate((sqrt(y+1)+y)/(y^2+1),y) = (%c*sqrt(x+1)2)/sqrt(x+1)]$ > > Why does it return empty instead of the original expression? Is it a > problem with abs? > > > Best, > Nijso > > > >  > One dashboard for servers and applications across PhysicalVirtualCloud > Widest outofthebox monitoring support with 50+ applications > Performance metrics, stats and reports that give you Actionable Insights > Deep dive visibility with transaction tracing using APM Insight. > http://ad.doubleclick.net/ddm/clk/290420510;117567292;y > _______________________________________________ > Maximadiscuss mailing list > Maximadiscuss@... > https://lists.sourceforge.net/lists/listinfo/maximadiscuss > 