egg|nomz|egg changed the topic of #kspacademia to: https://gist.github.com/pdn4kd/164b9b85435d87afbec0c3a7e69d3e6d | Dogs are cats. Spiders are cat interferometers. | Космизм сегодня! | Document well, for tomorrow you may get mauled by a ネコバス. | <UmbralRaptor> egg|nomz|egg: generally if your eyes are dewing over, that's not the weather. | <ferram4> I shall beat my problems to death with an engineer.
<bofh>
whitequark: okay having read the QC wiki I... agree *way* too much that that's me on too many stimulants (tho the OCD-like symptoms I get in that case are of the repeated-counting sort, like having to type sentences some multiple of 5x until it feels right, usually either 5 or 15x).
<egg|zzz|egg>
bofh: do you have family on a space station too
<bofh>
egg|zzz|egg: negatory
e_14159 has quit [Ping timeout: 182 seconds]
e_14159 has joined #kspacademia
awang has quit [Ping timeout: 190 seconds]
<whitequark>
bofh: told ya
awang has joined #kspacademia
<SnoopJeDi>
if I said to you the phrase "integer NaN" would you consider that weird?
<bofh>
I mean I'd just consider it to be equal to (1 << (type width - 1)) as a signed int since apparently that's what Intel converts NaN to integers as in a particular instruction (I forget which).
<bofh>
:P
<SnoopJeDi>
lol
<UmbralRaptop>
;8ball do exploding dice throw plastic shrapnel everywhere?
<kmath>
UmbralRaptop: It is decidedly so
<bofh>
I mean they're exploding dice. kmath is obviously correct.
<SnoopJeDi>
oh wow. "We must demand more of cosmology than just piling on components or constants to a model to reproduce observations. Otherwise, we would still happily be adding epicycles to the Ptolemaic model of planetary motion."
<SnoopJeDi>
Rocky Kolb throwing fireballs in Nature (article entitled "Is dark energy really a mystery?")
<kmath>
<prabhakardurga> @Newpa_Hasai We perceived Gravity and Light differently than reality. I showed in my book that acceleration due to… https://t.co/GAvq52SKxl
<SnoopJeDi>
ooh, original discussion looks interesting
<SnoopJeDi>
...that reply substantially less so
<e_14159>
SnoopJeDi: Ah. In that case, I did see it. I was looking for it learning the compression format :D
<SnoopJeDi>
heh
<e_14159>
Which, admittedly, would have been extremely cool.
APlayer has joined #kspacademia
<whitequark>
;8ball should i go sleep
<kmath>
whitequark: Outlook good
<whitequark>
;8ball or maybe continue hacking
<kmath>
whitequark: As I see it, yes
<whitequark>
...
<egg|phone|egg>
!Wpn whitequark
* Qboid
gives whitequark a cup of tea
tawny has quit [Ping timeout: 383 seconds]
BPlayer has joined #kspacademia
APlayer has quit [Ping timeout: 383 seconds]
<egg|zzz|egg>
bofh: well I have an example where you have p-2 bits after the round bit so it can't be much less than that
<egg|zzz|egg>
bofh: not sure how you adapt the proof of observation 21 to 2=3 tho
<egg|zzz|egg>
bofh: but 0|01111111111|0000000000000000000000000000000000000000000000000011; has a cube root with alarmingly many 1s
BPlayer is now known as APlayer
<egg|zzz|egg>
bofh: not sure how to get a long sequence of 0s, but yeah, seems you need roughly double the bits
<egg|zzz|egg>
bofh: hm although I'm getting chains of 1s after a round bit of 1 which isn't so annoying for round to nearest
egg|phone|egg has quit [Ping timeout: 190 seconds]
egg has joined #kspacademia
egg|zzz|egg has quit [Ping timeout: 186 seconds]
egg|phone|egg has joined #kspacademia
<egg>
bofh: yeah not sure how to get long sequences of 1s after a round bit of 0 for the cube root
<egg>
Is there an obvious pattern to 0|10000000001|1101101011010011101011110100100000010000100000000000; ? that was the fairly bad example that I found randomly
<egg>
bofh: seems 0|10000000001|1100001111010100010101110011001001101101010000000000; was the worst I found randomly
<egg>
with 17 1s after a round bit of 0
<egg>
bofh: could it be that you need only p/3 more bits to round correctly rather than p for round to nearest?
<egg>
!wpn whitequark
* Qboid
gives whitequark a fuzzy check
<bofh>
it's possible, actually, but I'm not sure how or why. hoping Atlas responds,but I'll take another look myself as well.
<egg>
!wpn bofh
* Qboid
gives bofh a cadmium unicode abuse̊̊̊̊̊̊̊̊̊̊̊̊̊̊̊̊̊̊̊̊
<egg>
!wpn atlas
* Qboid
gives atlas a buffered trait
<egg>
!wpn котя
* Qboid
gives котя a bar borogove
<egg>
!wpn the котяchrome kitten
* Qboid
gives the котяchrome kitten a lugubrious wrench
<egg>
bofh: how does your bound of p+1 bits work? I have no idea how to generalize observation 21
<egg>
bofh: tbh I'm not even sure I understand the proof of observation 21
<bofh>
...I think that might be where my derivation falls apart, sec.
Snoozee is now known as Majiir
<egg>
!wpn bofh
* Qboid
gives bofh a Müller delegate
<bofh>
yeah I think I'm misapplying observation 21, trying to understand its proof well enough to explain it right now >_>
<egg>
bofh: s/ex/eggs
<Qboid>
egg thinks bofh meant to say: yeah I think I'm misapplying observation 21, trying to understand its proof well enough to eggsplain it right now >_>
<bofh>
right. indeed :)
awang has quit [Quit: Lost terminal]
<egg>
bofh: fwiw at best I have a max relative error of 2^-15.49 after the double Newton and inversion (when optimizing γ for that, otherwise 2^-15.41) so I can probably safely clobber to 16 bits?
<egg>
bofh: but it doesn't improve my bounds for the rounding error
<egg>
bofh: my bound for the rounding error doesn't improve because I have something like 5*x^3+17*y (x^3 exact), which becomes (5x^3(1+δ1)+17y(1+δ2))1+δ3 which I end up bounding by saying 5x^3(1+δ1)+17y(1+δ2) = 5x^3+17y + 5x^3δ1+17yδ2, 5x^3δ1+17yδ2 <= (5x^3+17y)u so 5x^3(1+δ1)+17y(1+δ2) = (5x^3+17y)(1+δ4) for some δ4 <= u and that doesn't improve if δ1=0
<egg>
bofh: is there a way to have the bound on the sum improve when improving the bound on only one term?
<egg>
I meant |5x^3δ1+17yδ2| <= (5x^3+17y)u and |δ4| <= u of course
tawny has joined #kspacademia
<bofh>
egg: I don't *think* so, but let me finish wirking thru obs.21. Also that is a nasty as hell error bound
<egg>
bofh: which error bound is nasty?
<bofh>
(5x^3(1+δ1)+17y(1+δ2))1+δ3
<bofh>
anyway, I'm still not sure I understand this proof myself (which prolly explains why I got nonsense trying to generalize it from sqrt to cbrt
<bofh>
+)&
<bofh>
+)*
<egg>
bofh: so I can improve things, but honestly improving |δ4| <= u to |δ4| <= 17/(17+5(1-ζ))u (ζ being smallish, the relative error between x^3 and y) doesn't sound like a nice improvement
<bofh>
That strikes me as the *opposite* of an improvement. Sure it's a marginally tighter bound, but it's much nastier.
<egg>
bofh: well, yes, but I'd expect that having one of the operations exact would improve things, so it's nice to improve the proof correspondingly
<egg>
why is john regehr no longer a cat
<egg>
bofh: lol, were it computed exactly the Householder 6th order step would bring a guess with a relative error of 2^-14 to a relative error below 2^-100
<egg>
bofh: so, good news, any misrounding that we're seeing is rounding in the Householder step
<bofh>
egg: which is what I'd expect, honestly, but *where* in it.
<egg>
bofh: well, the operations that are not exact
<bofh>
thank
<egg>
bofh: like I think I have a ~12u bound (call it 1.01*12u or whatever, the usual mess from multiplying (1+δ)s), so it's not awful
<egg>
it's just that it obviously can't be exact
<egg>
bofh: now I need to know how many bits I'd need, and what a detection of possible misrounding would be
* egg
casts "summon cat"
* egg
is apparently not very good at summoning cats
<egg>
bofh: I only have "summon lesser numericist", that's not going to cut it for this one,
<SnoopJeDi>
"summon cat" is really high-level evocation
<SnoopJeDi>
(*not actually true)
<SnoopJeDi>
holy crap what, AD&D rules for Find Familiar: "While the familiar is within 12", the familiar's hit points are added to the caster's. If a familiar is slain, the caster loses double the familiar's hit points, permanently."
<Qboid>
UmbralRaptop thinks SnoopJeDi meant to say: "summon cat" is really high-level conjuration
<SnoopJeDi>
hmm right you are
<SnoopJeDi>
I always conflate the two, because abjuration was where I was at
<egg>
!wpn UmbralRaptop
* Qboid
gives UmbralRaptop a miscible geodesic
<bofh>
20:30:37 <@egg> bofh: now I need to know how many bits I'd need, and what a detection of possible misrounding would be
<bofh>
it's honestly the latter that I have no idea how to even think *about*
<SnoopJeDi>
egg, geodesics in GR seem pretty compatible with the notion of miscibility
<egg>
bofh: huh?
<egg>
bofh: that seems somewhat feasible?
<bofh>
egg: eggsplain?
<egg>
so the last few (ceiling(lg(12)) or so) bits are garbage
<egg>
but look at the non-garbage bits, and see if they put you near a midpoint? (i.e. all 1s or all 0s past the round bit, depending on the round bit)
<bofh>
hrm. okay, but how do you tell if you *are* near a m--OH oh I see.
<bofh>
I apparently fail at thinking today, sorry.
<egg>
now there's a performance question, namely finding the round bit without spending ages of bitshiftery on the critical path
<egg>
that seems tricky
<bofh>
so my first thought it using bit-scan-reverse and clever maskery, but I'm not sure how bad that'll be.
<bofh>
tangent: what the heck would use meter-bytes per second as a unit?
<SnoopJeDi>
a sneakernet :D
<SnoopJeDi>
(had this conversation on another network)
<egg>
bofh: hm, that's bandwidth*length, some sort of proxy for "amount of data in flight" if you don't know the speed of light in your material? that's too convoluted...
<SnoopJeDi>
I viewed it [datasize]*[spatial velocity] so it's a data "velocity"
* Qboid
gives UmbralRaptop an American transformer with a compactification attachment
<egg>
UmbralRaptop: kozai!
* UmbralRaptop
collides with 471325 Niku.
<egg>
meow
<bofh>
go me: "yeah I don't need to grab oven mitts let me just use this spare *aluminum foil*... OUCH"
<bofh>
I can derive Wiedemann-Franz off the top of my head but damn if I can't internalize its consequences.
<SnoopJeDi>
bofh, ow! for a pan?
<bofh>
Yep.
<SnoopJeDi>
I usually throw a towel over my shoulder so that if I'm *really* lazy/forgetful I can always use that
<SnoopJeDi>
and also for...towel stuff and cooking kitsch :P
* egg
pours cold water on bofh
<egg>
bofh: so I'm wondering whether Householder 5th order might be enough
<egg>
its relative error if computed exactly should be bounded by 2^-73
<bofh>
egg: I think so, for at least <1ULP precisiob
<bofh>
precision*
<egg>
bofh: if we're just looking for faithfulness 4th is enough :-p
<egg>
but that's boring
<bofh>
wait really? since 1 Newton gets you to ~17 th--yeah correct
<bofh>
oh in that case 5th order prolly suffices *and* is likely easier to reason about
<egg>
no, *two* newtons + inversion get you 2^-14
<egg>
(4th is 2^-57, if you can get your roundings below those four bits you're faithful)
<egg>
but faithful is boring
<egg>
5th is 2^-73
<bofh>
right, two Newtons. I keep overestimating how good your starting guess is.
<egg>
(note, the 2^-14 also counts clobbering, and leaves plenty of room for roundings and other discretisations that I didn't analyse in the first phase)
<egg>
and you have 17+53 bits at most in the Householder step, right?
<egg>
wait no is it at least or at most
<egg>
yeah it's at least so while I'll use that in the analysis reducing the householder isn't safe in general
<egg>
but then you might get fewer roundings from 5 than from 6 (not obvious though)
<egg>
blarg I'd need to run experiments but for that I need a correctly-rounded cbrt
<egg>
bofh: why do I need a correctly-rounded cbrt to implement a correctly-rounded cbrt
<bofh>
rofl
<bofh>
22:19:16 <@egg> but then you might get fewer roundings from 5 than from 6 (not obvious though)
<bofh>
not obvious but I suspect true, tho I don't know how to prove it immediately
<egg>
bofh: this seems like a tradeoff and therefore something that you want to look at statistically rather than with maximum norms
<egg>
bofh: which is why a correctly-rounded cbrt would be nice
<egg>
you don't happen to have one lying around do you
<egg>
bofh: also the cbrts (in libms) that are out there seem to be mostly shit
<egg>
many are just Sun's, sometimes with weird tweaks
tawny has quit [Ping timeout: 186 seconds]
<egg>
glibc seems to have its own thing and also no comments on the provenance of the unholy polynomial, but with an argument reduction like that I doubt it's faithful
<bofh>
yeah like I legit suspect your impl might be already among the best in existence
<bofh>
not bad for a casual nerdsnipe
<egg>
also there are no correctly-rounded ones because libmcr didn't bother
<egg>
neither did crlibm fwiw
ferram4 has quit [Read error: -0x1: UNKNOWN ERROR CODE (0001)]
<bofh>
so basically I wonder if you can do the ULP bump in your householder term via a similar double-double residual thing. But that still leaves the problem of isolating *where* the roundoff is happening.
<egg>
I'm not sure what a double-double residual thing looks like
<egg>
but anyway, lemme write an overkill mpir-based correctly-rounded cbrt
tawny has joined #kspacademia
<egg>
does mpir provide a rounding to double thing, or do i have to or my sticky bit by hand like in the olden days
<egg>
hm mpz_get_d truncates
<bofh>
I think you have to OR in your sticky bit, yeah.
<iximeow>
if it was a sticky bit wouldn't it just.. stick.... smh hardware
<egg>
bofh: it's the, uh, early eighties, go for it?