Work at SourceForge, help us to make it a better place! We have an immediate need for a Support Technician in our San Francisco or Denver office.

## [Maxima-bugs] [ maxima-Bugs-820188 ] Simplifying inf and minf

 [Maxima-bugs] [ maxima-Bugs-820188 ] Simplifying inf and minf From: SourceForge.net - 2004-03-21 21:10:07 ```Bugs item #820188, was opened at 2003-10-08 15:46 Message generated for change (Comment added) made by macrakis You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=104933&aid=820188&group_id=4933 Category: None Group: None Status: Open Resolution: None Priority: 5 Submitted By: Stavros Macrakis (macrakis) Assigned to: Nobody/Anonymous (nobody) Summary: Simplifying inf and minf Initial Comment: The general simplifier currently treats the various non- standard objects (inf, minf, und, ind, infinity) as though they were ordinary variables. This leads to incorrect results (inf-inf => 0, inf*0 => 0), incomplete simplification (inf^3 doesn't simplify, though inf is always correct), and non-canonical representations (-minf doesn't simplify to inf). It also seems to me that minf should be represented uniformly as -inf, not as a special case. Special-casing these objects in the general simplifier will add a very small overhead to all simplifications. The case that reminded me of this problem is abs(minf) =>-minf. ---------------------------------------------------------------------- >Comment By: Stavros Macrakis (macrakis) Date: 2004-03-21 16:10 Message: Logged In: YES user_id=588346 More problematic cases with inverse functions: asin(sin(inf)) => inf This should either not simplify, or give IND (if it is clever) or UND (if it is less clever). but exp(log(inf)) => inf tan(atan(inf)) => inf and the like are OK (by accident, but, hey!) ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=104933&aid=820188&group_id=4933 ```

 [Maxima-bugs] [ maxima-Bugs-820188 ] Simplifying inf and minf From: SourceForge.net - 2003-10-08 19:46:04 ```Bugs item #820188, was opened at 2003-10-08 15:46 Message generated for change (Tracker Item Submitted) made by Item Submitter You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=104933&aid=820188&group_id=4933 Category: None Group: None Status: Open Resolution: None Priority: 5 Submitted By: Stavros Macrakis (macrakis) Assigned to: Nobody/Anonymous (nobody) Summary: Simplifying inf and minf Initial Comment: The general simplifier currently treats the various non- standard objects (inf, minf, und, ind, infinity) as though they were ordinary variables. This leads to incorrect results (inf-inf => 0, inf*0 => 0), incomplete simplification (inf^3 doesn't simplify, though inf is always correct), and non-canonical representations (-minf doesn't simplify to inf). It also seems to me that minf should be represented uniformly as -inf, not as a special case. Special-casing these objects in the general simplifier will add a very small overhead to all simplifications. The case that reminded me of this problem is abs(minf) =>-minf. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=104933&aid=820188&group_id=4933 ```
 [Maxima-bugs] [ maxima-Bugs-820188 ] Simplifying inf and minf From: SourceForge.net - 2004-03-21 21:10:07 ```Bugs item #820188, was opened at 2003-10-08 15:46 Message generated for change (Comment added) made by macrakis You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=104933&aid=820188&group_id=4933 Category: None Group: None Status: Open Resolution: None Priority: 5 Submitted By: Stavros Macrakis (macrakis) Assigned to: Nobody/Anonymous (nobody) Summary: Simplifying inf and minf Initial Comment: The general simplifier currently treats the various non- standard objects (inf, minf, und, ind, infinity) as though they were ordinary variables. This leads to incorrect results (inf-inf => 0, inf*0 => 0), incomplete simplification (inf^3 doesn't simplify, though inf is always correct), and non-canonical representations (-minf doesn't simplify to inf). It also seems to me that minf should be represented uniformly as -inf, not as a special case. Special-casing these objects in the general simplifier will add a very small overhead to all simplifications. The case that reminded me of this problem is abs(minf) =>-minf. ---------------------------------------------------------------------- >Comment By: Stavros Macrakis (macrakis) Date: 2004-03-21 16:10 Message: Logged In: YES user_id=588346 More problematic cases with inverse functions: asin(sin(inf)) => inf This should either not simplify, or give IND (if it is clever) or UND (if it is less clever). but exp(log(inf)) => inf tan(atan(inf)) => inf and the like are OK (by accident, but, hey!) ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=104933&aid=820188&group_id=4933 ```
 [Maxima-bugs] [ maxima-Bugs-820188 ] Simplifying inf and minf From: SourceForge.net - 2006-07-11 04:36:31 ```Bugs item #820188, was opened at 2003-10-08 13:46 Message generated for change (Settings changed) made by robert_dodier You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=104933&aid=820188&group_id=4933 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. >Category: Lisp Core - Simplification Group: None Status: Open Resolution: None Priority: 5 Submitted By: Stavros Macrakis (macrakis) Assigned to: Nobody/Anonymous (nobody) Summary: Simplifying inf and minf Initial Comment: The general simplifier currently treats the various non- standard objects (inf, minf, und, ind, infinity) as though they were ordinary variables. This leads to incorrect results (inf-inf => 0, inf*0 => 0), incomplete simplification (inf^3 doesn't simplify, though inf is always correct), and non-canonical representations (-minf doesn't simplify to inf). It also seems to me that minf should be represented uniformly as -inf, not as a special case. Special-casing these objects in the general simplifier will add a very small overhead to all simplifications. The case that reminded me of this problem is abs(minf) =>-minf. ---------------------------------------------------------------------- Comment By: Stavros Macrakis (macrakis) Date: 2004-03-21 14:10 Message: Logged In: YES user_id=588346 More problematic cases with inverse functions: asin(sin(inf)) => inf This should either not simplify, or give IND (if it is clever) or UND (if it is less clever). but exp(log(inf)) => inf tan(atan(inf)) => inf and the like are OK (by accident, but, hey!) ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=104933&aid=820188&group_id=4933 ```
 [Maxima-bugs] [ maxima-Bugs-820188 ] Simplifying inf and minf From: SourceForge.net - 2008-04-05 22:37:27 ```Bugs item #820188, was opened at 2003-10-08 13:46 Message generated for change (Comment added) made by robert_dodier You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=104933&aid=820188&group_id=4933 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: Lisp Core - Simplification Group: None Status: Open Resolution: None >Priority: 7 Private: No Submitted By: Stavros Macrakis (macrakis) Assigned to: Nobody/Anonymous (nobody) Summary: Simplifying inf and minf Initial Comment: The general simplifier currently treats the various non- standard objects (inf, minf, und, ind, infinity) as though they were ordinary variables. This leads to incorrect results (inf-inf => 0, inf*0 => 0), incomplete simplification (inf^3 doesn't simplify, though inf is always correct), and non-canonical representations (-minf doesn't simplify to inf). It also seems to me that minf should be represented uniformly as -inf, not as a special case. Special-casing these objects in the general simplifier will add a very small overhead to all simplifications. The case that reminded me of this problem is abs(minf) =>-minf. ---------------------------------------------------------------------- >Comment By: Robert Dodier (robert_dodier) Date: 2008-04-05 16:37 Message: Logged In: YES user_id=501686 Originator: NO Increasing the priority of this item. See also [ 1562671 ] Handling of infinities. ---------------------------------------------------------------------- Comment By: Stavros Macrakis (macrakis) Date: 2004-03-21 14:10 Message: Logged In: YES user_id=588346 More problematic cases with inverse functions: asin(sin(inf)) => inf This should either not simplify, or give IND (if it is clever) or UND (if it is less clever). but exp(log(inf)) => inf tan(atan(inf)) => inf and the like are OK (by accident, but, hey!) ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=104933&aid=820188&group_id=4933 ```