<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
		>
<channel>
	<title>Comments on: Division by zero</title>
	<atom:link href="http://guru.multimedia.cx/division-by-zero/feed/" rel="self" type="application/rss+xml" />
	<link>http://guru.multimedia.cx/division-by-zero/</link>
	<description>Just another WordPress weblog</description>
	<lastBuildDate>Wed, 10 Mar 2010 12:28:53 +0000</lastBuildDate>
	<generator>http://wordpress.org/?v=2.9.1</generator>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
		<item>
		<title>By: Michael</title>
		<link>http://guru.multimedia.cx/division-by-zero/comment-page-1/#comment-1810</link>
		<dc:creator>Michael</dc:creator>
		<pubDate>Wed, 02 Aug 2006 00:18:03 +0000</pubDate>
		<guid isPermaLink="false">http://guru.multimedia.cx/?p=43#comment-1810</guid>
		<description>&gt; Sure but if you generalize your algebraic system a bit and give up some (or all?) of
&gt; the nice properties, you can have an algebraic division by zero. Just look at IEEE 
&gt; floating point. :-) I’m sure there’s a good deal of disagreement over whether or not
&gt; IEEE inf/nan semantics are “nice” but it tends to do “the right thing” and sure 
&gt; beats exception handling IMO.

i do like the IEEE inf/nan semantics, and about loosing nice properties, well how many are strictly true for floating point numbers at all? 
associativity : try huge_val - huge_val + 1
distributivity: try (huge_val - huge_val)*huge_val (overflow)
inverse       : a * (1/a) (here 1/a probably cant be represented exactly)
a*b=0 requires a or b to be 0: try 2 really small numbers
...</description>
		<content:encoded><![CDATA[<p>&gt; Sure but if you generalize your algebraic system a bit and give up some (or all?) of<br />
&gt; the nice properties, you can have an algebraic division by zero. Just look at IEEE<br />
&gt; floating point. :-) I’m sure there’s a good deal of disagreement over whether or not<br />
&gt; IEEE inf/nan semantics are “nice” but it tends to do “the right thing” and sure<br />
&gt; beats exception handling IMO.</p>
<p>i do like the IEEE inf/nan semantics, and about loosing nice properties, well how many are strictly true for floating point numbers at all?<br />
associativity : try huge_val &#8211; huge_val + 1<br />
distributivity: try (huge_val &#8211; huge_val)*huge_val (overflow)<br />
inverse       : a * (1/a) (here 1/a probably cant be represented exactly)<br />
a*b=0 requires a or b to be 0: try 2 really small numbers<br />
&#8230;</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: Rich</title>
		<link>http://guru.multimedia.cx/division-by-zero/comment-page-1/#comment-1804</link>
		<dc:creator>Rich</dc:creator>
		<pubDate>Tue, 01 Aug 2006 23:07:45 +0000</pubDate>
		<guid isPermaLink="false">http://guru.multimedia.cx/?p=43#comment-1804</guid>
		<description>Sure but if you generalize your algebraic system a bit and give up some (or all?) of the nice properties, you can have an algebraic division by zero. Just look at IEEE floating point. :-) I&#039;m sure there&#039;s a good deal of disagreement over whether or not IEEE inf/nan semantics are &quot;nice&quot; but it tends to do &quot;the right thing&quot; and sure beats exception handling IMO.

An interesting aside: one might thing that having an infinity element is &quot;wrong&quot; because it&#039;s destructive or absorbing, in the sense that INF+x == INF for all x (except -INF). However this is actually true of almost all floating point numbers. For instance if y=2**80 then y+x == y as long as x is fairly small (how small is left as an exercise to the reader). So in a sense, this &quot;misbehavior&quot; is nothing special about infinity, but a nasty property of fixed precision floating point in general. Said differently, infinity is just like a &quot;really big&quot; floating point number at least 2**n times as large as any other, where n is the number of bits in the significand.

Interested readers unfamiliar with floating point should read this classic article:
http://docs.sun.com/source/806-3568/ncg_goldberg.html</description>
		<content:encoded><![CDATA[<p>Sure but if you generalize your algebraic system a bit and give up some (or all?) of the nice properties, you can have an algebraic division by zero. Just look at IEEE floating point. :-) I&#8217;m sure there&#8217;s a good deal of disagreement over whether or not IEEE inf/nan semantics are &#8220;nice&#8221; but it tends to do &#8220;the right thing&#8221; and sure beats exception handling IMO.</p>
<p>An interesting aside: one might thing that having an infinity element is &#8220;wrong&#8221; because it&#8217;s destructive or absorbing, in the sense that INF+x == INF for all x (except -INF). However this is actually true of almost all floating point numbers. For instance if y=2**80 then y+x == y as long as x is fairly small (how small is left as an exercise to the reader). So in a sense, this &#8220;misbehavior&#8221; is nothing special about infinity, but a nasty property of fixed precision floating point in general. Said differently, infinity is just like a &#8220;really big&#8221; floating point number at least 2**n times as large as any other, where n is the number of bits in the significand.</p>
<p>Interested readers unfamiliar with floating point should read this classic article:<br />
<a href="http://docs.sun.com/source/806-3568/ncg_goldberg.html" rel="nofollow">http://docs.sun.com/source/806-3568/ncg_goldberg.html</a></p>
]]></content:encoded>
	</item>
</channel>
</rss>
