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?")
awang has quit [Ping timeout: 190 seconds]
awang has joined #kspacademia
UmbralRaptop has quit [Remote host closed the connection]
UmbralRaptop has joined #kspacademia
<whitequark> !wpn egg
* Qboid gives egg a chain pharmacology
<whitequark> useful
<kmath> YouTube - Ayreon - Sail Away To Avalon (The Final Experiment) 1995
<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."
<UmbralRaptop> SnoopJeDi: s/evocation/conjuration/
<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"
<SnoopJeDi> (not that it'd ever be a useful one)
<UmbralRaptop> Starwisps full of qubits.
APlayer has quit [Ping timeout: 383 seconds]
<egg> !wpn UmbralRaptop
* 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 looks underneath bofh's coffee cup
<egg> also on second thoughts the cancellations in the double newton make me really uncomfortable https://github.com/eggrobin/Principia/blob/7a66ca5bab62a4f9bab67ab87a369899d7c2a614/benchmarks/cbrt.cpp#L158-L159
<egg> wait no they shouldn't cancel much because r³y is near 1
<egg> ok yeah that should be okish
<egg> bofh: any idea how to implement a slow correctly rounded cbrt?
<bofh> Nope, I don't have a correctly-rounded cbrt handy. But yeah you are unlikely to get much cancellation there. Sterbenz' Lemma and such.
<bofh> egg: mpfr? :P
<egg> hmm
<egg> I think it'd have to be mpir because msvc support, and they don't appear to have a cbrt
<bofh> they have a pow(x,y) tho
<egg> bofh: they have an nth root for ants O__o https://github.com/wbhart/mpir/blob/master/mpz/nthroot.c
<bofh> for ants?
<egg> s/ant/int probably
<Qboid> egg meant to say: bofh: they have an nth root for int probablys O__o https://github.com/wbhart/mpir/blob/master/mpz/nthroot.c
<egg> thuboid.
<bofh> thuboid indeed.
<bofh> ahh, it just calls mpn_rootrem
<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)]
ferram4_ has joined #kspacademia
<kmath> <GabrielRossman> @Aelkus Alas, as maize is a Columbian exchange crop, there is no word for "corncob" in koine Greek
<bofh> egg: doesn't libmcr have correctly-rounded pow(x, y) at the least?
<egg> bofh: yeah
<egg> bofh: but 1/3 is not representable, so that doesn't help much :-p
<bofh> True.
<egg> (yes, that's the cat, disguised as a human)
<bofh> HUH.
<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?
<kmath> <ShebaAJ> L-Cat and D-Cat ⏎ #CatsOfTwitter #isomers https://t.co/lOraRXEy5z
ferram4_ is now known as ferram4
<egg> ferram4: meanwhile I appear to have nerd-sniped myself into coming up with the best cbrt out there
<egg> ferram4: you don't need a cube root, do you
<ferram4> Uh... I don't think so?
<ferram4> I might need a... uh, hypercube root? Is that the name for it? :P
<egg> a fourth root? hmm
<ferram4> For handling radiation if I ever get there. Maybe.
<bofh> ferram4: sqrt(sqrt(x)) not good enough for you? :P
<egg> bofh: that's probably unfaithful
<egg> but it's going to be hard to be faithful and match its speed
<ferram4> :P
* UmbralRaptop gives ferram4 a woltan type telescope.
<egg> bofh: ok mpir compiles, tests pass
<egg> now to write the daftest cbrt
<bofh> rofl