From: C R Onjob Date: Mon, 7 Jul 2014 17:00:04 +0000 (+0800) Subject: Automatic commit of irc logs X-Git-Url: https://git.ucc.asn.au/?p=ipdf%2Fdocuments.git;a=commitdiff_plain;h=4a64734f03a9805c1c83612e394344fa632cd334 Automatic commit of irc logs You can create your own opportunities this week. Blackmail a senior executive. --- diff --git a/irc/#ipdf.log b/irc/#ipdf.log index 68fef4b..3a9cbd2 100644 --- a/irc/#ipdf.log +++ b/irc/#ipdf.log @@ -2809,3 +2809,140 @@ 23:41 < matches> I guess apt decided to remove it as part of apt-get autoremove in its infinite wisdom 23:41 <@sulix> I have decided to never call apt-get autoremove. 23:42 <@sulix> If at any point there are too many old packages for me to get things done, I'll just reinstall the OS entirely. +--- Day changed Mon Jul 07 2014 +08:40 < matches> I try to avoid it, but sometimes apt won't let me do anything because it would break some dependency +08:40 < matches> Although usually even after I run autoremove it complains +08:41 < matches> Had to use aptitude to fix my "You can'd have kde-runtime!" issues +08:45 < matches> Anyway wolfram alpha says that example +45,10 - +128 == +18446744073709551533,9 +08:45 < matches> is correct +08:45 < matches> Checking the algorithm using 8 bits it should work too +08:46 < matches> So it works as long as you supply the leading zeros... +08:46 < matches> (On that particular case...) +08:48 < matches> I hope it's not interpreting Arbint(128L) as Arbint(128u, ...) +08:48 < matches> Nope sanity seems to prevail there +08:50 < matches> Ah +08:50 < matches> Ok +08:50 < matches> First bug of the day: The subtracted argument needs to be resized +08:50 < matches> As I am doing (45,10) - (128) +08:59 < matches> :O +08:59 < matches> I passed the realops test +09:00 < matches> And it's also a lot faster now! +09:00 < matches> Probably because the subtraction bug meant it was spending a long time in division to get the wrong result +09:01 < matches> Yeah it should have been obvious division can't have been that slow for numbers starting at 64 bits since it does at most as many iterations as the number of bits +09:01 < matches> Oh well +09:02 < matches> Should probably not celebrate just yet, now the bezier looks really wierd again +09:04 < matches> Ok +09:04 < matches> Actually compiling with Real == Rational might be a better test +09:04 < matches> But it still passes +09:05 < matches> In particular it passes with Arbints where int64_t fails horribly +09:05 < matches> So something is right +09:05 < matches> Just not all of it... +09:08 < matches> The GPU rendering seems to workish +09:09 < matches> We really quickly end up with Arbints of size 30 digits or so :S +09:09 < matches> Which is big enough to give an overflow in doubles I think +09:10 < matches> Rational::ToDouble can probably be written as double(integer division) + Rational(remainder, quotient).ToDouble() +09:10 < matches> (With some things to stop it recursing infinitely) +09:20 < matches> Or even double(integer division) + double(remainder)/double(quotient) +09:20 < matches> I don't think any recursion is needed +09:22 < matches> Oh, there's a "pow" call that is probably broken +09:24 <@sulix> Yeah, I feel the growing quickly is just a fact of life. +09:25 <@sulix> Perhaps changing the zooming to avoid coprimes or something. +09:27 <@sulix> I'm pretty certain that about 3 seconds of zooming is enough to make us need precision and range to match measuring the size of the visible universe in Planck lengths, too. +09:28 <@sulix> "New biggest Arbint of size 173" +09:28 <@sulix> and counting... +09:34 < matches> haha +09:34 < matches> There are more issues I spotted with add and subtract +09:34 < matches> Basically you have to add the leading zeros - all of them +09:35 < matches> My patch only simulates adding one leading zero +09:35 < matches> Actually maybe I don't need to add them all, just enough until the borrow becomes zero +09:36 < matches> But whatever +09:36 < matches> If you're left with a borrow you can't assume that subtracting it from the next digit won't cause a borrow as well +09:37 < matches> Realops is not a good enough tester +09:42 <@sulix> Surely if there's borrow bit, subracting it from zero will always give another...? +09:42 < matches> You only need as many as there are digits in your number +09:42 < matches> At most +09:42 < matches> If you still have a borrow at the end +09:42 < matches> That means the result is negative +09:43 <@sulix> Yeah, that's what I thought: you need to cap the number of digits you add. +09:44 < matches> The problem was the algorithm before didn't finish all the borrows +09:44 < matches> eg: 100 - 2 would have become "-8" +09:44 < matches> Because 2 only has one digit +09:44 <@sulix> My powers of mathematics tell me that that is not quite correct. +09:45 < matches> What, that our algorithm was wrong? +09:45 <@sulix> No, that 100-2 is not -8 +09:45 < matches> Yes +09:45 < matches> Yes that's the problem :P +09:46 < matches> So basically the two numbers need to be the same size but since we have a constant argument I'm sticking in a "borrow_digits" vector if there is a borrow +09:46 < matches> Addition also needs it for carry +09:46 < matches> Damn +09:47 < matches> I'd hoped that might fix the beziers not looking like beziers on the CPU bug +09:50 <@sulix> I've pushed code to clear the carry/borrow flag before adding/subtracting. +09:50 <@sulix> I don't think any bug is triggered, but there was the potential for off-by-one errors. +09:52 < matches> Argh no +09:52 < matches> Merge +09:53 < matches> Yeah I'm pushing a fix for bugs that I don't think we've seen (yet) +09:54 <@sulix> Out of curiosity, I tried removing the Simplify() calls from Rational. +09:54 <@sulix> Relatedly, I've coined the term "NaN soup" +09:54 < matches> Oh, clearing the carry/borrow flag might actually fix a bug with the code I just committed +09:54 < matches> No wait it won't +09:55 < matches> Eh it's still kind of dangerous to assume it isn't set to start with +09:55 <@sulix> I think the flag was probably already cleared by the code the compiler generated, but that might not be the case if it's optimized. +09:55 < matches> One of my early attempts had inline adc instructions in a for loop +09:56 < matches> Which failed miserably because the for loop was clearing the carry flag :P +09:57 <@sulix> For some reason "*=" segfaults if optimization is enabled, but I don't know why. +09:57 < matches> Yuk +09:58 <@sulix> Somehow we end up with "mul" as a null reference. +09:58 < matches> Rataional::*= or Arbint? +09:58 <@sulix> Arbint +09:58 <@sulix> (So, also rational) +09:58 <@sulix> Valgrind isn't picking anything up. +09:58 < matches> null references are the worst +09:59 < matches> Since I'm pretty sure the point of a reference is that it is never null... +09:59 < matches> I'm sure this doesn' +09:59 < matches> t stop people from deliberately creating null references +09:59 < matches> And also checking that they are not null +10:02 <@sulix> Tried compiling with clang. Nope. +10:02 <@sulix> Apparently not even #include compiles with clang. +10:02 < matches> It might be worth implementing a non assembly version of those functions +10:03 <@sulix> Yeah, that's always a good idea. +10:03 <@sulix> The assembly ones are more fun, though. +10:16 < matches> Hmm I should probably head towards the meeting +16:23 < matches> I have pushed a Gmpint wrapper thing +16:23 < matches> It mimics Arbint as closely as possible. +16:24 < matches> Well by that I mean I just wrapped all the calls to mpz_add() etc in operators +16:24 < matches> It doesn't have all of Arbint's more esoteric functions +16:24 < matches> If we need bit shifts I think I can add them +16:27 < matches> So, writing stuff... +16:28 < matches> Running arbint_vs_gmpint.test in valgrind takes a fair while +16:28 < matches> We will have the definitive answer of just how terrible our multiplication is compared to the Professional (TM) implementation +16:29 < matches> I do have some good news, I think our string conversion might be better +16:29 < matches> Well if you ignore the division +16:31 < matches> *= is about 11 times slower +16:32 < matches> Most of that is in std::vector::resize() +16:32 < matches> But even just mul_digits is greater than the entire Gmpint::operator*= +16:32 < matches> The plot thickens as I try division +16:32 < matches> Which is a good opportunity to get food because it will probably take an hour +16:34 < matches> Note: Don't disable Debug messages if you want time to get food :( +16:35 < matches> And division is just under 100* slower +16:36 < matches> No +16:36 < matches> 1000* +16:37 < matches> So... if we change Rational to Rational... +16:41 < matches> We still get {nan,nan,nan,nan} eventually but it is generally less shoddy +16:50 <@sulix> Cool: looking at this now. +16:50 <@sulix> I'm digging through the gmp source code as well. +16:51 <@sulix> They have a similar "divide by single int64_t" optimization. +16:51 <@sulix> Also their code is 90% preprocessor macros. +16:51 < matches> Welp +16:51 < matches> At least we have a readable Arbint +16:52 < matches> I don't know what use a readable but slow implementation is +16:52 <@sulix> Ah: I see what they're doing: this is quite clever, particularly from a pure maths point of view. +16:52 <@sulix> They've got a natural number implementation, and have then built their integer representation around that. +16:53 <@sulix> The natural numbler implementation is just a huge set of directories with different assembly implementation. +16:53 <@sulix> So there's an "x86_64" directory, and in that there's a bunch of assembly + a bunch of directories with optimized versions for different individual processor models. +16:55 <@sulix> Also their assembly has lots of ASCII art comments. +16:56 <@sulix> and macros. +17:07 < matches> Yeah "just use GMP" is probably the answer +17:08 < matches> Their Makefiles are pretty intimidating +17:22 < matches> I like that they seem to store the sign as part of the size +17:22 < matches> If something has a negative size it is negative and has |size| digits +17:34 < matches> I guess I will try and write some sort of report about how we implemented Arbitrary Integers but they are terrible compared to existing implementations :P