23:42 < matches> How I have missed you
23:42 < matches> void Foo() {if (m_next != NULL) m_next->Foo();}
23:42 < matches> <3
+--- Day changed Fri Sep 05 2014
+09:26 < matches> It sort of kind of works
+09:26 < matches> Except when it breaks
+09:26 < matches> ParanoidNumber::Simplify needs improvement
+09:26 < matches> Also operator+=
+09:26 < matches> operator-=
+09:26 < matches> operator*=
+09:26 < matches> and operator/=
+09:26 < matches> But it's definitely a number
+09:27 < matches> It just occasionally does things in totally the wrong order'
+09:28 < matches> So basically the idea is if you have an inexact (or overflow/underflow) operation, you delay it, and then in theory you can rearrange the operations so you have a smaller error...
+09:28 < matches> It seems to give better results than floats for tests/paranoidcalculator
+09:29 < matches> But that might be because it is initialised off 3/10 and the float starts at 0.3
+09:30 < matches> It could all be totally useless
+09:30 < matches> It probably is totally useless
+09:31 < matches> I have a hunch that even if it's terrible it might beat true arbitrary precision arithmetic
+09:31 < matches> In terms of actually being able to use it
+09:31 < matches> Who needs mathematics when you have blind intuition...
+--- Day changed Sun Sep 07 2014
+11:37 < sulix> Explicit mentions of hitting floating point precision issues in the xkcd comic: http://chromakode.com/post/notes-on-xkcd-pixels
+17:33 < unmercifulfish> mwahahaha
+17:34 < unmercifulfish> you can't escape my stalkerish tendencies now
+--- Day changed Mon Sep 08 2014
+11:10 < matches> This channel seemed like such a good idea at the time...
+11:19 < sulix> (So did the quadtree...)
+12:08 < Pommers> http://chromakode.com/post/notes-on-xkcd-pixels
+12:10 < sulix> It's gettign crowded in here.
+12:10 < sulix> Pommers: We were looking at that yesterday. The XKCD guys had it easy.
+12:11 < Pommers> Lets get all the people in here
+12:42 < unmercifulfish> IPDF PARTY
+13:49 < matches> Hmm, maths is harder than I thought
+15:41 < Pommers> Speaking of math, I know a guy who is looking for people versed in maths and willing to work on psuedo random number sets
+--- Day changed Wed Sep 10 2014
+11:50 < matches> So, compiling with mpfr reals is not as simple as including the mpfr real header and doing a typedef
+11:50 < matches> As there appear to be compiler errors in mpfr
+11:51 < matches> Does anyone actually check that things compile before including them in debian..
+11:53 < matches> I'd expect this sort of thing from Fedora
+11:58 < matches> Never mind it's namespace issues
+11:58 < matches> I'm sorry debian
+12:15 < matches> Something is horrendously broken about mpfrc++
+12:16 < matches> Oh
+12:17 < matches> #if REAL >= REAL_RATIONAL was not a wise choice
+12:21 < sulix> Ah...
+12:24 < matches> mpfrc++ is at least as precise as doubles but slower
+12:24 < matches> I never actually found the limit for doubles
+12:24 < matches> I should do that first
+12:26 < matches> Hmm, things start to disappear at around 4e-11 but you can still add stuff and it looks fine
+12:27 < matches> Ok doubles go crazy at 1e-17
+12:27 < matches> 1e-15 even
+12:30 < sulix> Is that zooming in on the origin, or somewhere further away?
+12:31 < matches> Somewhere further away
+12:31 < matches> If you translate towards the origin you can actually see the shapes start to get better
+12:31 < matches> It's actually pretty cool
+12:35 < matches> There's something dodgy with starting the View with low width/height as opposed to zooming in to the same width/height
+12:37 < matches> mpreal doesn't seem to want to show anything
+12:39 < matches> I think it's well past time we automated the zooming/translating process
+12:39 < matches> Sitting here zooming for 20 minutes is not really an effective use of time...
+12:47 < matches> Speaking of which, the CPU shading evaluates the fill points lazilly now, so you don't have to wait 5 minutes even with doubles just to load an SVG
+15:39 < sulix> For all of the hangers on... quadtrees are now slightly more functional.
+15:39 < Pommers> "functional"
+18:40 < iceweaselOS> Apparently talking in ICC isn't allowed
+18:41 < iceweaselOS> ICC
+18:41 < iceweaselOS> dammit
+18:41 < iceweaselOS> it has autocorrect
+18:42 < iceweaselOS> Humphrey the rabbit does not work :(
+18:42 < iceweaselOS> it gets stuck in pause
+--- Day changed Thu Sep 11 2014
+10:53 < matches> I wonder who that was
+10:59 < matches> "... for some reason in irram they decided to let x<y loop forever if x=y ..."
+10:59 < matches> That's...
+10:59 < matches> Ok
+10:59 < matches> Fine
+11:00 < matches> sulix: How many "x < y" checks do we have?
+11:10 < sulix> A finite number..., I guess?
+11:10 < matches> iRRAM appears to do some sort of fancy wrapping of MPFR
+11:11 < matches> So I'm not hopeful
+11:11 < matches> Considering MPFR seems to slow down hideously
+11:11 < sulix> Wrap all of the numbers inside other numbers.
+11:11 < matches> I did some more ParanoidNumber stuff
+11:11 < matches> Maybe one day it will actually give the correct result
+11:11 < matches> Then I can actually implement Simplify() ...
+11:12 < sulix> http://en.wikipedia.org/wiki/Binary_GCD_algorithm
+11:12 < sulix> (If you want fast gcd for bigints, btw)
+11:14 < matches> Should I plead "I had assignments due" or "I was seeing if Humphrey The Rabbit would work on a Firefox OS phone" in the progress meeting...
+11:14 < matches> iRRAM does seem to have a friendly install script
+11:15 < sulix> As long as you don't plead the FITH, you're probably fine. :P
+11:16 < matches> I'm fairly certain that floats are the best possible number representation and you need to do something more clever than just change your number representation if you want an arbitrary precision document
+11:16 < matches> Something like... some kind of... quad... tree
+11:17 < sulix> Do not use those words. You may not be able to vanquish what you summon.
+11:23 < matches> I need to write an abstract...
+11:24 < matches> "We compare different number representations and find them all to be useless"
+11:24 < matches> Hmm, something non commital
+11:25 < matches> "By the date of this conference we will hopefully have something interesting to say"
+11:25 < matches> "We discuss the drawbacks of adding IRC channel logs to git repositories"
+11:26 < matches> Ah nooo
+11:26 < matches> iRRAM uses "REAL"
+11:28 < matches> Also someone's been using too much javascript because there are all these extra ';' in their headers and it annoys -Werror=pedantic
+11:58 < sulix> ... :-(
+15:04 < matches> Spot the slight mathematical flaw in iRRAM
+15:04 < matches> inline LAZY_BOOLEAN operator == (const REAL& x, const REAL& y){ return (y<x)&&(x<y) ; }
+15:05 < matches> inline LAZY_BOOLEAN operator != (const REAL& x, const REAL& y){ return (y<x)||(x<y) ;}
+15:06 < matches> inline LAZY_BOOLEAN operator <= (const REAL& x, const REAL& y){ return (x<y); }
+15:06 < matches> They don't seem to have equality
+15:06 < matches> But that doesn't stop them implementing the operators...
+18:21 < sulix> Clearly the way to fix your computer's clock issues: http://jackf.net/bezier-clock/
+18:22 < matches> Against all better judgement I am still trying to fix ParanoidNumber
+18:22 < matches> And oh my goodness that is amazing
+18:23 < matches> But
+18:23 < matches> It still thinks it's 02:23:31
+18:23 < sulix> Unless I fix the quadtree view code, infinite precision only works if the coordinate you're zooming in on can _not_ be represented as a float.
+18:24 < matches> ?
+18:24 < matches> ??
+18:25 < sulix> So if you zoom in on a coordinate that is exactly representable as a sum of powers of two, then you're always zooming in on the boundary between two quadtree nodes.
+18:25 < matches> Haha
+18:26 < matches> Could you use an extra "centre" node?
+18:26 < matches> That would be redundant though
+18:26 < matches> Hm
+18:26 < sulix> Nah, I just need to actually get around to supporting displaying content from more than one node at a time.
+18:32 < matches> ParanoidNumbers seem to actually construct properly now
+18:32 < matches> At least, if you construct them and convert back to doubles, they are within 5% of the double
+18:33 < matches> Now... simplifying...
+18:33 < sulix> With float ParanoidNumbers or double ParanoidNumbers?
+18:33 < matches> doubles
+18:33 < matches> But I'm testing the traversal of the list(s) when converting back
+18:34 < sulix> Ahhh...
+18:34 < matches> You need two recursive functions and I really hope I don't get stack overflows...
+18:35 < matches> You start with "value = Head.value * Head.MultiplyFactors + Head.AddTerms"
+18:35 < matches> Then define MultiplyFactors as "1 * f1.AddTerms * f2.AddTerms * ..."
+18:36 < matches> Then AddTerms is "0 + t1.MultiplyFactors + t2.MultiplyFactors + ..."
+18:36 < matches> It gets confusing how you deal with division and subtraction...
+18:37 < matches> I'm sure you can write that as a non recursive function... somehow...
+18:37 < matches> I don't seem to be overflowing the stack though
+18:38 < matches> So 666 operations have taken 5 minutes
+18:38 < matches> But that's without simplifying anything
+18:38 * sulix is currently traversing quadtree nodes via needlessly complicated recusion.
+18:38 < matches> I am quitely confident that I may be able to render a frame in at most 10 years
+18:39 < sulix> Clearly in your seminar, you should start zooming in and when it gets slow just say "If you'll bear with me for a moment" and then just leave the room.
+18:39 < matches> The thought has crossed my mind...
+18:41 < matches> Something that is kind of cool is I can change the digit to be something like uint8_t and see how well it converts to floats
+18:41 < sulix> That is pretty cool.
+18:41 < matches> It will be when I implement it that is
+18:41 < sulix> How well _does_ it convert to floats?
+18:42 < sulix> (Also, sudden thought: is NaN a valid mark for this project, as I am getting the feeling it should be...)
+18:42 < matches> My paranoid number tester does occasionally fail with "NaN != NaN"
+18:42 < matches> That's good!
+18:42 < matches> They both got NaN!
+18:43 < matches> Well, ideally I will be able to make it so that the ParanoidNumber *doesn't* get NaN
+19:17 < sulix> Hmm... I think the ext4 driver just crashed on my computer.
+19:18 < matches> :S
+19:18 < sulix> I didn't know that was possible.
+19:25 * sulix -> other computer
+19:31 < matches> I'm inventing cool terminology
+19:31 < matches> Paranoia
+19:31 < matches> Is the number of ParanoidNumbers...
+19:33 < sulix> "Peeking around corners looking for NaNs, wearing a tinfoil hat to guard against surious SIGFPEs, it's... ParanoidNumber!"
+19:33 < matches> That is the best description
+19:33 < matches> Well
+19:34 < matches> It actually kind of blindly walks around the corner into the SIGFPE and then freaks out and runs back around it
+19:35 < sulix> It's like running away from the fireball in slow motion.
+19:37 < matches> I'll at least win an award for most original number representation
+19:37 < matches> (He hopes)
+19:37 < matches> (It's probably not)
+19:38 < matches> (It's probably equivelant to one of the many alternative number representations that I didn't look up...)
+19:38 * sulix also hopes there is an award for most buggy implemention of a quadtree.
+19:38 < matches> (Specifically, the ones in the Handbook of Floating Point arithmetic that were described as "curiously useless")
+19:40 < sulix> (Googling "curiously useless" yields the phrase: "My boss is curiously useless. He fanatically creates an abundant amount of work for everyone while at the same time manages to get nothing done.")
+19:40 < sulix> (I suspect they're referring to iRRAM)
+19:40 < matches> Bahaha
+19:43 < matches> I think that simply replacing floats with int8_t actually does work
+19:44 < matches> Which is cool because it is easier to test if an operation with int8_t can be represented exactly
+19:44 < matches> But on the other hand there will be fewer operations that can be represented exactly
+19:45 < matches> I think this may actually work
+19:46 < matches> You don't need arbitrary precision to represent screen space and you are converting from view space to screen space
+19:47 < matches> So maybe it won't be that terrible, even though it would need a lot more digits to represent the same arbitrary precision value
+19:47 < matches> I think
+19:47 < sulix> You need more than an int8_t to represent screen space.
+19:47 < sulix> (An int16_t would do it, though)
+19:48 < matches> You just need to be able to represent each individual factor in the operation
+19:48 < matches> factor and term
+19:48 < sulix> You may (probably will) need factors > 127
+19:48 < matches> Probably
+19:50 < matches> If I just implement an "Exact" template function...
+19:50 < matches> Uh oh, templates
+19:51 * sulix thinks that he's approaching the worst recursive subroutine ever written.
+19:52 < sulix> (It has four switch statements in it so far)
+19:57 < matches> Template errors
+19:57 < matches> Aargahasdf
+19:58 < matches> Compilers are so good at identifying exactly what error you made and so useless at actually providing any hint of how you can fix it
+19:58 < matches> It's totally different from like "expected ';' before ..."
+19:59 < sulix> I saw a feature request for Google translate to support "gcc -> English".
+19:59 < matches> I want to specialise some template static member functions...
+19:59 < matches> That was my first mistake...
+20:00 < matches> Ok, they don't need to be static member functions, they can just be ... whatever you call a function that has no namespace associated with it
+20:01 < sulix> Functions...?
+20:01 < matches> Bah
+20:01 < matches> I would say "Regular functions" but they tend to be less common in C++
+20:02 < sulix> I've heard them called "first-class functions" before.
+20:03 < matches> That's a little elitist
+20:03 < sulix> I'm sort-of enamoured with the idea of "business-class functions" and "economy-class functions," though.
+20:11 < sulix> BTW, I just commited something that doesn't compile. Fixes will come shortly, it was just the easiest way to get it from computer A -> computer B.
+20:13 * sulix has made a typo and copy-pasted it into 16 places.
+20:13 < matches> copy-paste is best practice...
+20:14 < matches> It irks me that "a -= b" is equivelant to "a += (-b)" but there is no "a /= b == a *= (-b)"
+20:14 < matches> Well there is sort of, but only for rationals
+20:14 < sulix> The operator you're looking for is (1 / b)
+20:14 < matches> Yes, but - is quicker
+20:14 < sulix> This is true.
+20:15 < matches> I mean 3 can be represented exactly but 1/3 cannot
+20:15 < matches> With floats
+20:15 < matches> Most annoying
+20:15 < matches> I'm currently trying to reduce all the superflous "{0 + ...}" in ParanoidNumber
+20:16 < matches> It likes to create 1000 element lists with 900 zeroes in a row
+20:35 < unmercifulfish> this is gripping reading
+20:35 < unmercifulfish> so glad I am a part of this
+20:35 < matches> This is the cutting edge of useless research
+20:41 < sulix> "The bézier tiptoed out of bed. What an adventure it would be to go beyond the quadtree node in which it had lived its entire life. Its mother had told it sternly that it was dangerous to wander the dark wastes beyond the root node. Bobby Bézier had never believed the stories, though: there were no such things as wild NaNs that ate all of the coefficients of naughty boys. Bobby looked up at the sky: the infinite void of night penetrated only by the deb
+20:43 < Pommers> Oh yeah. One of the people in cs has a nice post on their door about rabbits that I want to grab a copy of
+20:50 < matches> I have a "TrustingOp" and "ParanoidOp"
+20:50 < matches> I think I'm having too much fun...
+20:54 * sulix has decided to give up actually coding and take up writing bézier curve fanfiction full time.
+20:55 < sulix> (People say it's derivative, but it's just about to reach a turning point)
+21:15 < unmercifulfish> qdb
+23:09 < matches> Oh dear
+23:09 * matches curses kahan
+23:10 < matches> I do not understand how this works, but if I delete terms that are "-0" things break
+23:13 < matches> So I got to the point where ParanoidNumber gave results that were reasonably close to just using a normal double without simplifying them
+23:14 < matches> And now I am basically adding random lines of code and running the tester and seeing if it still works :S
+--- Day changed Fri Sep 12 2014
+00:15 < matches> This reminds me of the James Micken comment about addition and multiplication basically being the same thing...
+01:19 < matches> Oh my goodness
+01:19 < matches> I think ParanoidNumber just worked for one very specific case!
+01:19 < matches> ParanoidNumber: 0.3 + 0.3 + 0.3 = 9/10, ToDouble() -> 0.9000000000000000222044604925031308084726
+01:20 < matches> double: 0.3 + 0.3 + 0.3 = 0.9000000000000001332267629550187848508358
+01:20 < matches> And strtod("0.9") = 0.9000000000000000222044604925031308084726
+01:23 < matches> For 0.2+0.2+0.3 = 7/10 it has an error of 1e-16 compared to doubles which apparently have no error
+01:24 < matches> But as floats it has an error of 1e-8 compared to 4e-8
+01:24 < matches> Hmm, why does 7.0 / 10.0 give a bigger error than 0.2 + 0.2 + 0.3
+01:24 < matches> Oh
+01:24 < matches> It'll be denormals probably
+01:25 < matches> That is... quiet irritating
+01:27 < matches> So... it is sometimes better than a float but only if there is a full moon and you sacrifice thrice the number of one tenth of unity goats three times
+01:28 < matches> The other times it breaks because subtraction is totally FITH
+01:29 < matches> Oh, it should be able to do 1/3 + 1/3 + 1/3 except my calculator tester doesn't allow me to enter non decimal numbers
+01:32 < matches> I think 0.3+0.3+0.3 is the only thing it can do better than regular floats
+01:32 < matches> Woo
+01:40 < matches> Ah it is better at beating doubles when it is using doubles as the digit type
+01:40 < matches> But it still is sometimes worse if you have a small number of operations
+01:40 < matches> Probably because one division is less precise than several additions
+01:42 < matches> I'm going to keep telling myself that this is useful
+01:42 < matches> After I sleep
+01:51 < Pommers> It isn't currently a full moon...
+01:51 < Pommers> Also
+01:51 < Pommers> Go to bed
+11:27 < matches> It was a full moon after I sacrificed the goats
+11:40 < Pommers> Stop toying with space matches
+--- Day changed Sat Sep 13 2014
+09:25 < unmercifulfish> I feel that the logs for this chat should just be added to qdb
+09:25 < unmercifulfish> < matches> It was a full moon after I sacrificed the goats
+12:36 < Pommers> Should make a QDB bot for submitting them
+16:20 < matches> When sulix is awarded the nobel prize for his work on quad trees, I will be proud to be a part of this channel
+16:21 < Pommers> Until then you won't be?
+16:23 < matches> I've been thinking of adding a "grep -v matches" before the automatic log commit
+17:45 < matches> I am a horrible person
+17:45 < matches> I am exploiting that "delete" acting on a NULL pointer has no effect
+17:46 < matches> "delete Operation(new ParanoidNumber(a), ADD)"
+17:47 < matches> Where Operation will either return the first argument or NULL
+17:50 < matches> At the moment I'm very pleased with how cleverly I am about to shoot myself in the foot
+17:50 < matches> We'll see how I feel after I pull the trigger
+17:53 < matches> I have either written an extremely elegant or an extremely segfaulting function
+17:57 < matches> The latter is looking more and more likely
+17:57 < matches> But I'm sure there is beauty underneath
+17:57 < matches> Like the ugly duckling!
+17:59 < matches> There's still hope, it turns out I'm segfaulting way before I even get to that
+18:01 < matches> Apparently 2+1 is 6, but doubles think 2+1 is 5
+18:02 < matches> "Freedom is the freedom to say 2+2=4, if that is granted, all else follows"
+18:06 < matches> Ok, 1 + 1 is 2
+18:06 < matches> I think we can call that a result
+18:06 < matches> Write the thesis and we're done here
+22:18 < matches> 1 + 0.3 = 13/10 and 13/10 + 0.2 = Segfault
+22:18 < matches> Getting close
+22:19 < matches> Now I'm doomed to not sleep until it works because I'm never going to remember how this works
+22:20 < Pommers> Got a whiteboard?
+22:20 < matches> I do actually but it's in the other room
+22:20 < matches> And it does not have space for this
+22:22 < matches> I don't think I've ever used so many delete operators...
+22:23 < matches> Also constructing a 4 diretional list on the stack then stealing one of the branches
+22:23 < matches> It's a game of "dodge the double delete!"
+22:24 < matches> Which reminds me, we have copious memory leaks in an external library
+22:24 < matches> 'ld' ?
+22:25 < matches> /lib/x86_64-linux-gnu/ld-2.19.so
+22:25 < matches> Not sure if that's something I'm doing wrong
+22:26 < matches> Turns out you can't pipe valgrind's output to less
+--- Day changed Sun Sep 14 2014
+18:23 < matches> http://szmoore.net/ipdf/sam/abstract.txt
+18:24 < matches> You know
+18:24 < matches> It sounds a lot more boring than it has been
+18:24 < matches> I also need a title
+18:24 < matches> "Number Representations and Precision in Vector Graphics" ?
+18:24 < matches> I'm too scared to pick something punny...
+18:26 < matches> Libreoffice thinks that is 147 words and pluma thinks it is 150...
+18:26 < matches> Oh
+18:26 < matches> hyphenated IEEE-754
+18:28 < matches> I think the first sentence could probably be less mind numbingly boring
+18:28 < matches> My last thesis started with "In this project" which seems terribly not academic
+18:29 < matches> (Every time I read that thesis I get a little more convinced that the markers didn't actually read any of it)
+18:29 < matches> ParanoidNumbers are not going well
+18:30 < matches> Like, it's hard to debug where things go wrong when you have a list like this:
+18:30 < matches> debug: main (tests/paranoidcalculator.cpp:75) - a is: {3*(23*(398123+(1/10+(2/100+(3/1000+(5/10000+(1/100000+(2/1e+06+(2/1e+07+(3/1e+08)))))))))+(3*(398123+(1/10+(2/100+(3/1000+(5/10000+(1/100000+(2/1e+06+(2/1e+07+(3/1e+08)))))))))/10+(4*(398123+(1/10+(2/100+(3/1000+(5/10000+(1/100000+(2/1e+06+(2/1e+07+(3/1e+08)))))))))/100+(1*(398123+(1/10+(2/100+(3/1000+(5/10000+(1/100000+(2/1e+06+(2/1e+07+(3/1e+08)))))))))/1000+(2*(398123+(1/10+(2/100+(3/1000+(5/10000+(1/100000+(2/1e+06+(2/1e+07+(3/1e+08)))))))))/10000+(3*(398123+(1/10+(2/100+(3/1000+(5/10000+(1/100000+(2/1e+06+(2/1e+07+(3/1e+08)))))))))/100000))))))/10+(1*(23*(398123+(1/10+(2/100+(3/1000+(5/10000+(1/100000+(2/1e+06+(2/1e+07+(3/1e+08)))))))))+(3*(398123+(1/10+(2/100+(3/1000+(5/10000+(1/1 ...
+18:31 < matches> That's without simplifying it
+18:31 < matches> But when it gives the wrong results before you even simplify it, that's bad
+18:32 < matches> I'm preeety sure it's not just giving the wrong results because it has a stupid number of terms/factors
+18:32 < matches> It's wrong enough that there's an extra factor or a factor missing or I don't even
+18:34 < matches> Hmm
+18:34 < matches> I want to add "Unlike paper, ..." before the third sentence
+18:34 < matches> I'm going to Captain Obvious
+18:38 < matches> :(
+18:38 < matches> Panic mode is well and truly activated now
+--- Day changed Mon Sep 15 2014
+14:00 < sulix> matches: You need to put the title in: "Keepin' it real: Staying afloat on the sea of document precision"
+--- Day changed Tue Sep 16 2014
+12:25 < matches> I think I'm sinking
+12:27 * sulix has failed to come up with a suitable sinking/syncing pun.
+12:27 < sulix> Or, for that matter, a reason why the quadtree clipping sometimes breaks.
+12:33 < matches> Hey, at least multiplication doesn't sometimes break
+12:33 < matches> That's fairly major
+12:34 < matches> My graph traversal for the paranoid number is somewhat flawed
+12:34 < matches> Yeah it's a giant graph
+12:34 < matches> Smell the memory cooking
+12:34 < matches> I should do some performance tests
+12:34 < matches> Even if I don't have anything to performance test...
+12:34 < matches> We did promise graphs
+12:35 < matches> (The other kind of graph)
+12:35 < sulix> How are you traversing the graph?
+12:35 < sulix> (The first kind)
+12:36 < matches> Originally I was alternating between multipying and adding, but that doesn't work if the first term in a factor has factors of its own
+12:36 < matches> I could probably still use that but I'd have to add zeroes or something
+12:37 < matches> Thinking of it as a linked list is wrong anyway, as factors can have terms and terms can have factors and I'm not making any sense am I
+12:37 < matches> Maths can be made up of maths
+12:37 < matches> I kind of regret basically promising to have this done in my abstract...
+12:37 < sulix> Hmmm...
+12:40 < matches> Anyway, either I am creating the graph wrong and traversing it correctly, or creating it right and traversing it incorrectly, or they are just both totally wrong
+12:41 < matches> Leaning towards the latter
+12:43 < sulix> You need to traverse it from the bottom-up, I think.
+12:50 < matches> Yeah, I need to change both the creation and traversal
+12:50 < matches> Repeated divisions need to change into a division of a number multiplied by a number
+12:51 < matches> Then the traversal is relatively trivial
+12:55 < matches> Division is annoying
+12:55 < matches> Why does maths need division
+12:55 < matches> All the other operations make sense
+12:56 < matches> Someone should reinvent mathematics without a concept of division
+12:56 < matches> We'd all be happier
+12:56 < sulix> I'm pretty certain there's a formal proof of that.
+12:57 < sulix> Most number systems don't have the concept of division.
+12:57 < matches> Haha
+12:57 < sulix> (The integers, for example)
+12:57 < matches> They have division with remainder though?
+12:58 < matches> Ah
+12:58 < matches> But you don't get a single number out
+12:58 < matches> You get two
+12:58 < matches> So it's not a proper operation?
+13:00 < sulix> It's not a binary operation, and it's not the inverse of division.
+13:00 < sulix> *multiplication
+13:07 < Pommers> Guild debate. Pretty sure I have the best camera angle here
+13:43 < matches> Guild debates are beyond the scope of this project
+13:44 < matches> Urgh I'm regretting distinguishing between ADD and SUBTRACT now
+13:44 < matches> Just ADD and MULTIPLY should be all the universe needs
+13:51 < matches> You have to be doing something wrong when you are using a triple pointer
+13:57 < matches> Delicious triple pointers
+13:57 < matches> Now I feel like a triple chocolate milkshake
+13:58 < matches> Ok, I have integers 0->9 adding and subtracting preeettty well now
+14:13 < sulix> Ah, the power of modern technology!
+14:29 < sulix> When in doubt, more debug output!
+14:55 < sulix> Ah ha! I have solve (read: hacked horribly around) the quadtree bug.
+14:56 < Pommers> http://xkcd.com/859/
+14:56 < sulix> Basically, adding a bunch of fake roots in fixes it.
+14:56 < sulix> Details at 11.
+14:56 < sulix> Pommers: You are a terrible person.
+14:57 < Pommers> Oh wait. It's there. I should sit closer to my screen
+15:32 < matches> Ok, I'm pretty sure Paranoid Numbers are the worst idea ever
+15:32 < matches> Possibly worse than iRRAM
+15:32 < matches> I mean, in theory you can simplify things
+15:32 < matches> But when you can't, you just use ridiculous amounts of memory
+15:33 < matches> I don't think you can simplify that many things either
+15:33 < matches> If I get it working enough I can demonstrate that it is a terrible idea at least...
+16:46 < matches> Oh my goodness it is kind of working
+16:46 < matches> I've said this before...
+16:47 < matches> But it's at least at the point where it gives suspiciously similar answers to the right answer
+16:48 < matches> As opposed to suspiciously off by factors of a random number
+17:31 < matches> So I think all I have to do now is simplify the damn things
+17:31 < matches> There are all sorts of amazing optimisations like not using a std::vector for the terms and not using seperate std::vector for + and -
+17:31 < matches> And I think you can probably optimise it even more if you just use doubles
+17:31 < matches> But
+17:31 < matches> It is better at repeated division/multiplications
+17:32 < matches> See TestMulDivIntegers
+17:32 < matches> By better I mean slower
+18:50 < matches> I have pushed a thing
+18:50 < matches> Try not to judge me too harshly
+18:51 < matches> Also there's no way it will compile on Cabellera anymore
+23:06 < matches> So
+23:06 < matches> I just made SVGs load into the centre of the view...
+23:06 < matches> And then I realised that is exactly the sort of thing that will break sulix's quad tree
+23:06 < matches> Sorry sulix
+23:07 < matches> My role in this project is basically to make sulix have to do more work...
+23:21 < Pommers> Why'd you break cabellera?
+23:30 < matches> I didn't break cabellera
+23:30 < matches> I used C++11 auto range iterators
+23:30 < matches> for (auto add : m_next[add])
+23:31 < matches> As opposed to: for (vector<ParanoidNumber*>::iterator i = m_next[ADD].begin(); i != m_next[ADD].end(); ++i) ParanoidNumber * add = *i; ...
+23:31 < matches> Cabellera's g++ is too old for such amazing things
+23:32 < matches> But I was at a point where I needed to change like 50 things from iterating over linked lists to iterating over some kind of hideous graph of std::vectors
+23:32 < matches> Stuff typing all that
+23:32 < matches> I broke the quad tree because I thought it would be nice to have SVGs automagically appear in the middle of the screen
+23:33 < matches> As opposed to the top left underneath all the debug output
+23:49 < sulix> matches: You are too kind.
+23:49 < sulix> The quadtrees are actually working fine at the moment, by virtue of me modifying SolveCubic to no longer solve cubics.
+23:51 < Pommers> return null;?
+--- Day changed Wed Sep 17 2014
+00:03 < matches> Wait what
+00:04 < matches> Did you remove Cubic Beziers
+00:04 < matches> Because I liked having Cubic Beziers
+00:04 < sulix> I'm still trying to work out why it works myself.
+00:04 < sulix> Nope, still cubic béziers, solvecubic now just returns some things which I'm pretty certain actually aren't roots as well.
+00:05 < Pommers> Do either of you want to trade? I'll work on iPDF and you can fix my housemates computer
+00:05 < matches> Hah
+00:05 < matches> Set up that Jenkins server and we'll talk
+00:06 < Pommers> The Container exists for Jenkins
+00:06 < Pommers> So it's been started
+00:06 < matches> I wish CS would stop thinking up names for things that are also names for other things
+00:06 < matches> Container
+00:06 < matches> Puppet
+00:06 < matches> Orchestration
+00:06 < matches> For god's sake
+00:06 < matches> Paranoid Number is totally a legit name
+00:07 < Pommers> Stop being paranoid about things matches
+00:07 < matches> "Tree" is acceptable because it at least looks like a tree
+00:07 < Pommers> Also, coming to dinner?
+00:07 < matches> There is dinner?
+00:07 < matches> When?
+00:07 < matches> It's midnight...
+00:07 < Pommers> Thursday
+00:07 < matches> Oh
+00:07 < matches> I suppose
+00:08 < matches> Thursday is typically the post meeting freak the hell out day
+00:08 < matches> Monday Tuesday and Wednesday being the pre meeting freak the hell out days
+00:08 < matches> Friday is the I should really prepare for my Physics tute day
+00:09 < Pommers> Saturday is "o god coderdojo day"
+00:09 < matches> Yeah
+00:09 < matches> Sunday is I should really not be playing computer games but I will anyway day
+00:09 < matches> No wait last sunday was a freak the hell out day as well, until they made me play monopoly
+00:09 < matches> Sorry, monotony
+00:10 < matches> Anyway how do you get valgrind to print number of flops
+00:10 < sulix> I'm just s/.*day/PANIC day/g at the moment.
+00:10 < matches> Your thing works!
+00:10 < matches> Sort of
+00:11 < sulix> thing?
+00:11 < matches> Quadtrees
+00:11 < Pommers> "thing"
+00:11 < sulix> Technically it works*
+00:11 < Pommers> "it"
+00:11 < matches> I have about 4 things I still haven't even tried yet
+00:11 < matches> And a couple of things that will work if you wait the lifetime of the universe
+00:12 < Pommers> Hmm... I should make my bed while this backup happens
+00:12 < matches> Bed is tempting
+00:12 < sulix> *The roots I'm using might not actually be roots, it doesn't work if you either pan, zoom out or anything other than zoom in on a single point forever.
+00:12 < Pommers> But having too much fun coding?
+00:13 < matches> I'm working towards actually making graphs of something
+00:13 < matches> I'm still working out exactly what I will graph
+00:13 < matches> flops seems important
+00:13 < matches> I'm basically replacing a single inexact flop with a lot of usually but not always exact flops
+00:14 < matches> And several hundred MB of memory...
+00:18 < matches> Ok, this can't be right
+00:18 < matches> To render one frame of an empty document takes 137,708 F64 operations
+00:18 < matches> I assume that means double
+00:19 < Pommers> That could use some optimizing...
+00:19 < Pommers> Make all the functions return null and see how that speeds it up
+00:19 < matches> -_-
+00:19 < matches> This is using regular doubles
+00:19 < matches> Not Paranoid Numbers
+00:20 < matches> ParanoidNumbers takes about 5 minutes to do 20000 operations at the moment...
+00:20 < sulix> I could believe it.
+00:22 < Pommers> I'd be paranoid if it took that long
+00:22 < matches> Don't make fun of the Paranoid Numbers
+00:22 < matches> They are a work of art
+00:23 < sulix> Part of me really wants to try compiling the quadtree with them, and part of me is terrified at the prospect.
+00:23 < matches> There isn't a REALTYPE for them yet
+00:25 < matches> They might work better if you had a giant Trie of them but I have no idea how to structure that
+00:25 < matches> At the moment there is one tree per number and the tree can have a variable number of children for each node... :S
+00:31 < matches> Anyway what performance metric do we want
+00:31 * matches consults the proposal
+00:32 < Pommers> What will be easier to do? Time or space?
+00:32 < matches> Time
+00:32 < matches> But Rowan was kind of keen on Space
+00:32 < matches> Number of flops is probably the best
+00:32 < Pommers> Just put some ascii art daleks in
+00:34 < matches> Ok, so 1 frame = 30,897 F32, 129,042 F64 and 1000 frames = 4,364,459 F32, 6,933,526 F64
+00:35 < matches> 6800 doubles to render a blank document
+00:35 < matches> Actually
+00:35 < matches> !
+00:35 < matches> There is a rectangle in it!
+00:35 < matches> Of width and height 0
+00:40 < Pommers> I almost have the container for jenkins fully set up now
+00:43 < Pommers> I just need to give it an IP and then just set up jenkins
+00:45 < matches> I was joking about Jenkins...
+00:46 < Pommers> I actually have a use for it...
+01:16 < Pommers> Housemates computer is fixed
+01:16 * Pommers sleeps
+01:29 < matches> Dammit
+01:29 < matches> I entered a timestamp of 10:56 instead of 22:56 and now my commit is at 13:27
+01:30 < matches> I tried git commit --amend --date= but it didn't quite work
+01:31 < sulix> Would it count as cheating on the performance metrics if time travel was involved?
+01:31 < matches> Nooo
+01:32 < sulix> As you can see, ParanoidNumber actually takes only -12 hours to render a frame by being so cautious it violates causality.
+01:32 < matches> So, the "spatial" metric can be: Number of pixels not the same, and mean minimum distance horizontally/vertically to the nearest set pixel in the original
+01:32 < matches> Because I said so
+01:32 < matches> A possible other metric would be the Fourier Transform
+01:33 < matches> But that's stupid
+01:33 < matches> -12 hours is pretty good
+14:43 < Pommers> Jenkins is set up and I can let you create an account if you want to play with it
+17:01 < matches> Best idea ever
+17:02 < matches> A performance test that saves the graph as an svg
+17:02 < matches> Then runs itself on the graph...
+17:05 < Pommers> recursive testing?
+17:05 < matches> Yes!
+17:07 < Pommers> Set your testing up in jenkins
+17:08 < matches> This is performance tests not sanity tests
+17:08 < matches> Or whatever they're called
+17:08 < matches> We don't need to make sure things work...
+17:08 < matches> We just need them to not work fastly
+18:35 < matches> SDL_WINDOW_HIDDEN is useful
+18:36 < matches> Actually I'm surprised it works
+18:37 < matches> As much as having ipdf constantly flashing up and stealing my window focus is exciting, I am relieved to be able to stop that
+18:37 < matches> Now I just need to stop the monitor from randomly flashing its menu and/or turning off...
+18:42 < matches> So I can show some graphs tomorrow, although they may not be graphs of actually useful things
+19:44 < matches> I hope you like ipython because we're using ipython
+19:50 < matches> git.ucc seems sick...
+--- Day changed Thu Sep 18 2014
+11:40 < matches> Good news!
+11:40 < matches> You can run ipdf on motsugo
+11:40 < sulix> I heard.
+11:40 < sulix> My good news is that I just added something to the quadtree.
+11:40 < sulix> (Sort-of)
+11:41 < matches> The GPU rendering doesn't work on motsugo though
+11:41 < sulix> I fail to be surprised.
+11:42 < matches> Does the quadtree work with the centred SVGs?
+11:44 < sulix> I haven't been brave enough to do the horrible merge that needs to happen.
+11:45 < sulix> I'm currently trying to work out how I'm going to pass which node that you want to add something to through all of the Add* code.
+11:52 < matches> Ah
+11:57 < matches> I'm about to hack around C++ 'const' correctness
+11:57 < matches> What could possibly go left
+11:57 < matches> I mean wright
+11:57 < matches> I mean lng
+11:57 < matches> asdf
+11:58 < matches> segmentation fault
+12:00 < matches> Well it compiled at least
+12:00 * matches notes that if he ever sees a function declared 'const' again he should not assume that it is actually const...
+12:01 < matches> Now to overload the new and delete operators...
+12:04 * sulix hides quietly in a corner.
+12:05 < matches> ParanoidNumber needs to call new and delete an excessive amount
+12:05 < matches> Because you might need to create a new one but you might not, but you can't tell in advance :S
+12:06 < sulix> So: pool or arena?
+12:06 < sulix> (I'd probably recommend an arena)
+12:06 < matches> I've not heard of an arena, which probably means its better
+12:07 < matches> It sounds traumatic though
+12:07 < matches> Remember these numbers are paranoid as it is
+12:08 < sulix> Basically allocate a large block of memory, every time you allocate return the next <n> bytes of it.
+12:08 < sulix> Delete is a no-op, everything is freed when you delete the entire arena.
+12:10 < matches> Hm I thought that was a pool
+12:11 < sulix> A pool is basically an array of objects of the same type that get reused.
+12:12 < sulix> Though nomenclature is pretty dodgy generally wrt memory management.
+12:12 < matches> SO thinks they are the same
+12:12 < matches> http://stackoverflow.com/questions/13381123/whats-the-difference-between-a-memory-arena-and-a-memory-allocator
+12:12 < matches> Actually no that's not quite the question I was looking for
+12:13 < matches> I said pool and it says "allocator"
+12:13 < matches> (But some guy with upvotes says arenas are also called pools)
+12:13 < matches> (Democracy has decided!)
+12:13 < matches> Ok I see the difference
+12:13 < matches> Yeah, I was going to use a pool, but I guess arena would be better
+12:14 < sulix> http://en.wikipedia.org/wiki/Memory_pool
+12:15 < sulix> http://en.wikipedia.org/wiki/Region-based_memory_management
+12:28 < matches> So, PN gives "inf" for an operation that doubles do fine
+12:29 < matches> But on the plus side, Wolfram Alpha gives "Wolfram alpha does not understand your query -344+(6+8/10 +...)"
+12:29 < matches> "Showing results instead for "6+8/10 +3/100"
+12:30 < matches> (The maths is syntactically correct, or at least, I'm fairly sure it is. I'm not actually going to count all those brackets...)
+12:31 < matches> I find it amusing that there is a number representation that is just "That number is too complicated, here is a similar looking one"
+12:32 < matches> Actually, correction
+12:32 < matches> *addition rather
+12:32 < matches> "Insert more money to calculate the number"
+12:32 < sulix> "Upgrade to wolfram alpha pro to use numbers with more factors"
+12:32 < matches> Yes
+12:32 < matches> That is pretty much what it says
+12:34 < matches> Hmm, I think PN should take a couple of minutes per frame at the moment
+12:34 < matches> I should probably actually test it
+12:39 < matches> That's a whole lot of compiler errors
+12:39 < matches> Argh
+12:39 < matches> I hate the "overloaded call to ClassConstructor(int) is ambiguous" errors
+12:40 < sulix> I think the idea of "compiler errors" is clearly too negative.
+12:41 < sulix> We should have "constructive compiler feedback" instead.
+12:41 < sulix> "warnings" should become "suggestions"
+12:41 < matches> I don't understand that type of eror
+12:41 < matches> The compiler is supposed to silently typecast the primitive types right?
+12:41 < sulix> Yes*
+12:41 < matches> So if you have a constructor for a double it will cast "0" to "0.0" and use that
+12:41 < sulix> Yes*
+12:42 < matches> If you implement constructors for *both* it will get confused
+12:42 < sulix> (If there isn't another constructor that is equal or better)
+12:42 < matches> If you implement constructors for only *one* it *still* gets confused
+12:42 < matches> Aaskdfasdf
+12:43 < matches> It's totally confused
+12:43 < matches> I think
+12:43 < matches> It sees the int
+12:44 < matches> Then goes "I can construct a ParanoidNumber off that"
+12:44 < matches> Then goes "But I can construct a ParanoidNumber off the const ParanoidNumber &"
+12:44 < matches> That doesn't make sense
+12:44 < matches> Why is the copy constructor ambiguous
+12:45 < sulix> That's exactly what I hate about c++.
+12:45 < sulix> (Also boost)
+12:51 < matches> It gets Real(0) mixed up with Real(const char * str)
+12:51 < matches> Really
+12:51 < matches> Why
+12:51 < matches> FFS
+12:52 < matches> std::string it is then
+12:52 < matches> Don't know why it had to complain about every single other constructor being ambiguous as well
+13:01 < matches> I've just realised
+13:01 < matches> ParanoidNumber is going to have to be thread safe
+13:01 < matches> As long as we want the control panel to work anyway
+13:01 < matches> Blergh
+13:05 < matches> Oh boy
+13:05 < matches> You know you are in trouble when "this == NULL"
+13:06 < matches> I feel like I am messing with forces beyond my ken
+13:06 < matches> I haven't even overloaded new yet
+13:06 < sulix> this == NULL is actually perfectly possible.
+13:07 < matches> Yeah but where is it coming from
+13:07 < sulix> It's the correct result if you call a member function of a null pointer.
+13:07 < matches> Yeah I know
+13:07 < matches> But
+13:07 < matches> But
+13:07 < sulix> (Is it time for captain valgrind?)
+13:07 < matches> That spits out so many errors due to other libraries :(
+13:07 < matches> I'm learning to use gdb more effectively
+13:07 < matches> I finally learned how to set breakpoints
+13:08 < matches> And print variables
+13:08 < matches> You can even get it to call functions
+13:08 < matches> That's cool
+13:08 < sulix> Yeah, gdb is pretty amazing.
+13:08 < matches> So I have this four dimensional tree of death
+13:08 < sulix> What you should do is setup the libstdc++ pretty printers.
+13:08 < matches> The child links are implemented as a std::vector of pointers
+13:08 < sulix> It makes gdb print stl containers nicely.
+13:09 < matches> Somehow there are null pointers in the vector
+13:09 < matches> That should really not happen
+13:09 < matches> I could check that the pointers are not null but I suspect that won't solve the underlying issue
+13:09 < matches> Of null pointers ending up in places
+13:10 < matches> Couldn't I do something like: 'p (Pointer*)vector.data()'
+13:10 < matches> I should try that
+13:11 < sulix> PANIC PANIC PANIC
+13:12 < sulix> Apparently my draft dissertation is due tomorrow.
+13:12 < matches> Wahtasdfasdf
+13:12 < matches> What
+13:12 < matches> When did this happen
+13:13 < sulix> http://undergraduate.csse.uwa.edu.au/year4/Current/dates.html
+13:14 < matches> :S
+13:14 < matches> I thought Rowan said you had two weeks...
+13:14 < matches> Or was that two weeks ago..
+13:14 < matches> Also I know I don't technically have to submit a draft dissertation but I share some level of panic
+13:15 < sulix> Yeah, I thought I had more time, too.
+13:15 < matches> I'm sure you can organise it with Rowan
+13:16 < matches> My last thesis was somewhat of a blur
+13:16 < matches> I'm not sure there was a draft
+13:17 < matches> You'll get through it
+13:20 < sulix> (The question is not so much if I'll get through it, but if I'll get through it in the next hour and forty minutes... :P)
+13:22 < matches> I give you permission to copy/paste my lit review
+13:22 < matches> Although to be honest it could do with less rambling about svg and postscript
+13:26 < sulix> btw, I've found a way to make the quadtree run as slowly as the rationals.
+13:28 < matches> How?
+13:28 < sulix> Totally broken linked lists?
+13:28 < sulix> (I think)
+13:29 < sulix> QuadTree nodes can now "overlay" other quadtree nodes, which is the way I'm hacking mutability in.
+13:29 < sulix> For some reason, if you zoom in and then zoom back out again, it ends up creating a new overlay for each individual curve.
+13:30 < sulix> Each overlay runs the entire View::Render function again, independently.
+13:30 < matches> Damn
+13:30 < matches> I don't understand how these vectors have NULL in them
+13:30 < matches> I have "assert(b != NULL)" before the only two places where things get added to them
+13:31 < sulix> Are asserts enabled? :P
+13:32 < matches> I thought that was Java
+13:32 < matches> Also python
+13:34 < sulix> I'm not actually sure about the standard asserts, but most of them do get disabled if you're not in a debug build.
+13:34 < matches> Ooh
+13:34 < matches> oh oh oh
+13:34 < matches> I always do this
+13:34 < matches> std::vector::vector does not construct with a size
+13:35 < matches> It constructs with elements
+13:35 < matches> So vector n(0) is baad
+13:35 < sulix> I always use vector(size, initialvalue)
+13:35 < matches> Nope that isn't it...
+13:35 < sulix> Or just use the default constructor if I want "empty".
+13:36 < matches> I'm already wrapping the billions of 'new's in a check that it isn't null
+13:36 < matches> What is going on
+14:40 < Pommers> matches: Fix your NTP already
+16:28 < matches> sulix: "That's actually not too bad, I may be rationalising it, but..."
+16:28 < matches> (We wouldn't want the spectators to miss any of the puns)
+16:28 < sulix> (For context: talking about the performance and correctness of rational numbers)
+23:35 < matches> Your predictions of Simplify leading to infinite loops were remarkably accurate
+23:36 < matches> That just means the number can be infinitely Simplified!
+23:49 < sulix> Simplify() { return 0; /* it can't get much more simple */ }
+23:49 < matches> Haha
+23:50 < matches> Well I just spent 15 minutes learning why I had the stupid ".test" extension on all the testers in the first place
+23:50 < matches> (Which I recently removed because it was stupid)
+23:50 < matches> Turns out it was there so that make clean could remove all the testers without needing to keep a list of them all
+23:51 < matches> And that no matter how many times I ran make clean, I was still running the same buggy executable from 7 hours ago...
+23:51 < matches> "Not so stupid after all!" says past matches
+23:51 < matches> "Shut up" says present matches
+23:52 < matches> "When are we going to sleep" says future matches at approximately 3am
+23:53 < matches> Things get wierd when you remove NTP
+23:53 < matches> I have a watch on my wrist but it's not the same
+23:55 < matches> "You know what the .test extension is still dumb, I'll just remember to rm them when they need rebuilding" says a slightly older present matches
+--- Day changed Fri Sep 19 2014
+00:00 < matches> Ah, good old copy paste and naming variables 'n' and 'm'
+00:01 < matches> Mever fails to segfault
+01:05 < matches> PN Yields: 1.0000000000000000000000000000000000000000
+01:05 < matches> PN is: 1
+01:06 < matches> Doubles Yield: inf
+01:06 < matches> TAKE THAT KAHAN
+01:06 < matches> Hmm
+01:06 < matches> I could multithread the paranoid number...
+01:07 < matches> At least, the Convert to double part of it
+01:11 < matches> Ah, it fails on the very next test though
+01:11 * matches regrest uncommenting the "return 0;"
+01:11 < matches> grects
+01:11 < matches> regrects
+01:11 < matches> dammit
+01:11 < matches> it is too aerly for this
+01:21 < matches> So ipython stores pngs as giant base64 encoded strings
+01:21 < matches> In JSON format
+01:21 * matches shudders at the commit diff
+01:23 < matches> Good luck sulix
+09:47 < sulix> "Bang, zoom, straight to the rounding error"?
+12:17 * sulix falls over in a heap of insanity and shame.
+17:20 -!- mode/#ipdf [+o matches] by OperServ
+17:20 -!- matches changed the topic of #ipdf to: IPDF: A Document Precision Playground
+17:20 <@matches> This is good reading
+17:21 <@matches> I just read "At its core, IPDF breaks documents" and choked on my drink
+17:22 * sulix thinks we might have a new slogan.
+17:23 <@matches> I think it's important that you don't specify what the initials actually stand for
+17:23 <@matches> People will think it's a fancy PDF viewer
+17:23 <@matches> Except it's really a broken SVG viewer
+17:25 < sulix> I don't intend to give any more explanation than IPDF™.
+17:25 < sulix> Or possible IPDFⓇ
+17:25 <@matches> I am jealous of your compose key
+17:26 < sulix> Mwäháhà!
+17:33 <@matches> Ah yeah, precision vs zoom doesn't work to well for doubles for some reason
+18:24 <@matches> Look at ParanoidNumber go
+18:24 <@matches> Look at it go!
+18:24 <@matches> Well you can't because you're not here
+18:24 <@matches> I should do a live stream
+18:24 <@matches> It is so exciting
+18:24 <@matches> It's been going 5 minutes but it hasn't failed any tests since I commented out the comparison against doubles
+18:25 <@matches> Yes
+18:25 <@matches> Eat all the memory
+18:25 <@matches> Soon you will grow strong
+18:27 <@matches> Actually I probably *want* it to start failing tests
+18:28 <@matches> Because if it gives the same result as a double it's not any better than a double...
+18:28 <@matches> At the very least it is mathematically interesting
+18:29 <@matches> I'm not sure Mathematically interesting and "Chemical Engineering Conference" go together
+18:29 <@matches> Also I don't have enough Maths training to say anything about it other than it is interesting
+18:29 <@matches> It is a ring of complete hidden sets of fields
+18:29 <@matches> Yeah
+18:29 * matches uses maths
+18:30 < sulix> Technically, I don't think that things which use floats can ever be rings or fields due to the whole rounding error thing.
+18:34 <@matches> Well
+18:34 <@matches> It's a tree
+18:34 <@matches> I can hold on to that
+18:34 <@matches> I understand trees
+18:35 <@matches> They have trunks and bark and leaves
+18:35 <@matches> Hmm, I should add a Bark sub class
+18:35 <@matches> I wonder if I can bring myself to implement the same test algorithm in Mathematica and compare the results
+18:36 <@matches> I think using Mathematica in research requires you to sell your soul though
+18:41 <@matches> Also Frames thinks that enabling optimisation will magically make PN less terrible
+18:41 <@matches> I'm somewhat skeptical
+18:41 <@matches> But here goes
+18:42 <@matches> (I am anticipating it will make it much faster, in that it will segfault after 2 operations)
+18:45 <@matches> Well it didn't segfault, but apparently "219123 != 219123"
+18:48 <@matches> Actually
+18:48 <@matches> It seems a lot faster
+18:48 <@matches> Hooray Frames
+18:48 <@matches> Thesis done
+18:49 < sulix> Does it speed up the GMP and/or Arbint rationals much?
+18:49 <@matches> Haven't tried yet
+18:49 <@matches> I need to adapt Paranoidtester into a general tester
+18:49 <@matches> Or was that realops
+18:49 <@matches> I forget
+18:49 <@matches> I have a lot of testers that I suspect do basically the same thing
+18:57 <@matches> Compiling with -Ofast does lead to
+18:57 <@matches> WARNING: main (main.cpp:29) - __STDC_IEC_559__ not defined. IEEE 754 floating point not fully supported.
+18:57 <@matches> (I am the best programmer I put in all the warning messages!)
+18:58 <@matches> And ipdf segfaults
+18:58 <@matches> But not the tester
+18:58 <@matches> In stbtt_FindGlyphIndex
+18:59 <@matches> Are we going to need to submit another pull request...
+19:17 <@matches> Ah
+19:17 <@matches> Adding all those "SanityCheck" calls may have slowed things down a tad
+19:17 <@matches> IPDF::ParanoidNumber::SanityCheck (this=0xe80a640, visited=std::set with 9775 elements = {...})
+19:23 <@matches> Sanity-Check-this - out
+19:24 <@matches> I think I need more sleep
+19:53 < Pommers> goto bed matches
+--- Day changed Sat Sep 20 2014
+21:22 <@matches> Overloading operator new and delete is kind of terrifying...
+21:25 <@matches> Things run blindingly fast
+21:25 <@matches> Until they segfault
+21:26 <@matches> I suspect std::vector does not take kindly to being destructed multiple times
+21:33 <@matches> Hmm
+21:33 <@matches> I need to make std::vector pointers instead?
+21:33 <@matches> That's getting a little convoluted...
+21:35 <@matches> Or what I really need is a delete operator that doesn't actually call the destructor automagically
+21:35 <@matches> (Even when you overload delete it still calls the destructor?)
+21:36 <@matches> I'm noticing a bit of a trend here
+21:36 <@matches> You can overload C++ operators but if you do it totally breaks everything
+21:36 <@matches> eg: You could implement a double() operator for casting to double but you're better off just writing Double() and using it everywhere because otherwise the compiler goes insane trying to use your operator in places
+21:37 <@matches> You can implement your own delete operator but that won't stop the compiler from doing everything it does with the standard delete...
+21:38 <@matches> The only operators you can overload (mostly) are the arithmetic ones
+21:39 <@matches> Also the compiler seems to occasionally just use the standard delete anyway which just makes everything TOTALLY INSANE
+21:39 <@matches> WHY
+21:39 * matches grumbles and prepares to write "Delete" and "New"
+--- Day changed Sun Sep 21 2014
+16:43 <@matches> I think I'm just an idiot
+16:47 <@matches> Arena doesn't help that much
+16:47 <@matches> Which is odd
+16:48 <@matches> If anything it is slower :(
+16:49 <@matches> It's hard to profile something that doesn't work in valgrind
+17:00 <@matches> On the other hand, removing all the "SanityCheck" calls is surprisingly effective...
+17:48 <@matches> Damn
+17:48 <@matches> I guess new and delete isn't as expensive as just doing a craptonne of branches
+22:33 <@matches> So, probably a better idea is to stop the CPU renderer from recalculating the object bounds every single frame
+22:33 <@matches> And update the object bounds when the view is changed instead
+22:34 <@matches> Since we don't really care what the original bounds are
+22:37 <@matches> This is basically what the quad tree does...
+22:37 <@matches> Well it changes coordinate systems as well
+22:37 <@matches> But I can zoom in a lot further now than I could before...
+22:38 <@matches> Until eventually there is a sigfpe
+23:19 <@matches> Ok
+23:19 <@matches> This is slightly worrying
+23:19 <@matches> I can zoom to {0.5,0.5,1e-41,1e-41} and insert things without any problem
+23:21 <@matches> The CPU renderer does tend to sigfpe
+23:27 <@matches> Man I feel really foolish now
+23:27 * matches makes plans to delete the IRC logs again
+23:32 <@matches> So
+23:33 <@matches> The good news is that GMP rationals are pretty effective when you do cumulative transforms on the object bounds as opposed to keeping the bounds static and transforming them to view coordinates
+23:34 <@matches> The bad news is that so are regular floats
+23:34 <@matches> I'm pretty sure it just means we need a better tester
+23:38 <@matches> Or
+23:38 <@matches> We lie
git.ucc.asn.au / ipdf / documents.git / blobdiff
UCC git Repository :: git.ucc.asn.au