21:52 < matches> Flood fill is not as easy as I had hoped
21:53 < matches> I have to start doing annoying geometry maths to work out what point I can start the flood fill at
21:55 < matches> Sigh
+--- Day changed Wed Aug 27 2014
+22:33 < sulix> Suddenly: ToAbsolute on ToRelative does not give original Bezier
+22:34 < sulix> I may need to rethink what my quadtree code is doing to those poor curves.
+22:51 < sulix> Never mind, that assertion happens _whenever_ trying to load cubicbeziers.svg.
+23:03 < sulix> Oh wow: you should see what happens if you start splitting and reparametrising beziers with bad precision.
+23:03 < sulix> 'tis "whacked"
+23:08 < sulix> http://davidgow.net/stuff/ipdf-a-slight-curve.png
+23:15 < sulix> And the Quadtree infinite precision for béziers now works*
+23:15 < sulix> *for some beziers.
+23:15 < sulix> * for some large finite value of "infinite"
+--- Day changed Thu Aug 28 2014
+11:35 < sulix> What time is it? It's NaN time!
+11:44 < sulix> Ah, so... horizontal lines have a height of zero in their bounds. This makes divides by zero happen in places.
+11:48 * sulix apologieses profusely for his latest "break absolutely everything" commit.
+11:57 < sulix> Yeah, making divide by zero crash rather than generating NaNs breaks a lot of things.
+11:57 < sulix> You'd be surprised by how often we divide by zero.
+11:57 < sulix> Mostly in the Quadtree code.
+11:58 < sulix> Because, damnit, mathematics can't beat me.
+12:20 < matches> Yes, lines have zero width... stupid lines
+12:21 < matches> I stopped the segfaults in shading by adding a depth counter to FloodFillOnCPU
+12:21 < matches> Which makes interesting shading patterns...
+12:22 < matches> I think it's time to fall back to the "Use the second algorithm on Wikipedia" approach
+12:23 < matches> I can still use a Flood Fill but hopefully a less segfaulty one
+12:29 < matches> I'm not sure about ToAbsolute and ToRelative...
+12:29 < matches> I thought they should be inverses but they seem not to be
+12:29 < matches> Oh wait, the divide by zero would do that
+12:30 < matches> That curve looks cool
+12:30 < matches> You should talk about it lots in the meeting
+12:31 < matches> For the whole meeting
+12:31 < matches> Nothing else
+12:31 < matches> Don't mention the total lack of progress I made...
+12:32 < matches> How much can I trust SolveCubic?
+12:40 < matches> Basically I'm going with randomly picking points until I find one inside the shape then starting a flood fill from that point
+12:41 < matches> Checking the pixels for the edges is not feasable
+12:42 < matches> If you scan along a bresenham line you could jump over the edge
+12:42 < matches> ... I see an "if false" in SolveCubic
+12:42 < matches> Slightly worrying
+12:43 < matches> Ah
+12:43 < matches> I approve of SolveCubic
+13:31 < matches> So
+13:31 < matches> Did you introduce the floating point exception or did I...
+13:45 < sulix> I just did.
+13:49 < sulix> SolveCubic may have small problems.
+13:50 < matches> Yes I am trying to rewrite it now...
+13:50 < matches> I swear we did this in CQM
+13:52 < sulix> Solvecubic also sometimes tries to take the square root of a negative number.
+13:52 < matches> Yep
+13:54 < sulix> I've pushed slightly less broken code.
+13:55 < sulix> Ny which I mean slightly more broken.
+13:55 < matches> ...
+13:55 < sulix> I'm avoiding divide by zeros by "if (denominator = 0) denominator = 1" style shenanigans.
+13:56 < matches> I'm slightly scared by the change to Rect::TransformRectCoordinates
+13:56 < matches> Oh right
+13:56 < matches> Yeah
+13:56 < matches> That seems...
+13:56 < matches> Scary
+13:56 < sulix> It works, scarily enough.
+13:56 < matches> Anyway I already ifdef'd the thing out of SolveCubic
+13:56 < matches> It's too slow for me though
+13:57 < sulix> And by works, I mean I haven't found any issues yet.
+13:57 < matches> I am brute forcing a point inside the shape
+13:57 < matches> This requires finding the intersections with horizontal and vertical lines for every single bounding bezier
+13:57 < matches> Then the "even or odd" test
+13:57 < matches> You only have to do it once
+14:05 < matches> I think SolveCubic would best be done by doing Newton Raphson or the Shooting Method between the endpoints and the turning points
+14:05 < matches> I'll see
+14:06 < matches> I'll try implement it and see if it's faster
+14:06 < matches> You may have to demonstrate my totally broken shading for me
+14:06 < matches> I haven't committed in a while
+14:41 < matches> Oh
+14:41 < matches> SolveCubic may not have been the bottleneck there...
+14:41 < matches> -_-
+14:41 < matches> The failure to update the variable for a while loop miiiight be more of an issue
+14:44 < sulix> Good, 'cause I'm thinking of "upping the SolveCubic accuracy" a bit.
+14:44 < sulix> Anyway...
+14:44 * sulix -> CS
+14:46 < matches> I've reimplemented SolveCubic
+14:46 < matches> In theory it works
+14:55 < matches> I reckon Binary Search is the only algorithm I am good at implementing :S
+14:57 < sulix> Oooh...
+14:57 < matches> What?
+18:56 < matches> So, the fact that we are not solving cubics analytically is probably important in terms of precision issues
+18:58 < sulix> Yeah, that's why I started trying to solve them analytically and then stopped and cried.
+18:58 < matches> :(
+18:59 < matches> There is a solution, it's just ugly
+18:59 < sulix> Nah: for the Quadtree, it didn't matter much. As long as the error went in the correct direction, you'd just lost a tiny bit of efficiency.
+19:00 < matches> Hmm
+19:00 < matches> I don't expect shading using arbitrary precision arithmetic will be particularly fast anyway...
+19:01 < sulix> Well, ideally most of the work in the shading will be done in screen-space anyway.
+19:01 < matches> Yes
+19:02 < sulix> And, of course, you don't need infinite precision for that because pixels/integers/etc.
+19:03 < sulix> So, fingers crossed, things shouldn't matter too much.
+19:03 * sulix realises that that is a maddeningly vague statement.
+19:03 < matches> Well
+19:04 < matches> I got the fill point to actually be in the correct location by actually solving the intercepts correctly
+19:04 < matches> But
+19:04 < matches> If you zoom *out* far enough, it can end up no longer inside the shape when transformed to screen space
+19:04 < sulix> Okay, new plan.
+19:04 < sulix> No zooming out.
+19:05 < matches> I wish there were other people in this channel so I could justify putting that in qdb
+19:20 < matches> There is a temptation to not require all those references to be const during rendering
+19:20 < matches> We might want the Path to be able to alter itself based on the view
+19:20 < matches> But I guess we'll take that path when we get to it
+19:22 < matches> It might be worthwhile caching Path's for fonts
+19:22 < matches> But I'd have to change the coordinates to be relative
+19:22 < matches> Too many coord transforms
+19:24 < sulix> Yup, that can be the subtitle of the thesis: "Too many coord transforms"
+19:26 < matches> "A coordinated approach to graphics"
+19:26 < matches> Oh wow
+19:26 < matches> That should be a textbook
+19:26 < sulix> "Transformers: Matrices in disguise"?
+19:30 < sulix> Okay, it turns out (if denominator is zero, make denominator 1) has one flaw.
+19:30 < sulix> Sometimes you should make the denominator... negative 1.
+19:30 < matches> ...
+19:30 < sulix> Somehow, I did not see this coming.
+19:30 < matches> I'm not sure how this maths works
+19:30 < matches> 1/0 != 1/-1
+19:30 < sulix> That's what they want you to think.
+19:31 < sulix> (Or maybe the bug I'm having is unrelated to that, but it seems like a fun guess)
+21:16 < matches> Floating Point Exception in fglrx!
+21:16 < matches> glXDestroyContext
+21:16 < matches> It only happens when the program is about to close
+21:16 < matches> So I'll be fine
+21:18 < sulix> Ah, maybe enabling floating point exceptions was a bad idea.
+21:18 < sulix> ...if it causes lots of "fglrxceptions"!
+21:21 < matches> Well fglrx is exceptional
+21:37 < matches> I'm falling back on just testing a crap tonne of points for "inside" and adding all the ones that are to a vector
+21:37 < matches> I think there are some false negatives in Path::PointInside
+21:37 < matches> Also FloodFill misses some edge pixels which makes no sense
+21:38 < matches> If it's next to a filled pixel it should get filled!
+21:47 < matches> So the disadvantage of using a breadth first search is that when your queue gets really big instead of getting a segfault you just get OOM
+21:48 < matches> segfaults are quick
+21:48 < matches> segfaults are like a pistol and oom is like drowning
+21:54 < sulix> There is no way a BFS floodfill should ever OOM
+21:54 < sulix> How many pixels are there, and how much are you storing per one?
+21:58 < matches> Probably max 256x256 pixels, 4 way fill
+21:58 < matches> It does not like rabbit_simple.svg
+22:04 < matches> Yeah there is *something* causing it to get in a loop
+22:04 < matches> Because obviously my BFS didn't check for loops
+22:14 < matches> -_-
+22:14 < matches> It is in a loop
+22:14 < matches> Because there is a region with fill colour of white
+22:14 < matches> And the flood fill is just "If it isn't white, stop"
+22:14 < matches> Maybe I should set the background to have 0 alpha or something
+22:15 < matches> Alpha seems to not actually do anything at the moment
+22:27 < matches> http://szmoore.net/ipdf/who-the-hell-needs-antialiasing-anyway.png
+22:44 < matches> http://szmoore.net/ipdf/shady-the-fox.png
+22:47 < matches> rabbit_simple.svg actually doesn't work as well as rabbit.svg
+22:48 < matches> I think one of the fill points of the outer ear is inside the inner ear
+22:54 < sulix> Oh my... They're beautiful!
+23:07 < matches> Ah crap
+23:07 < matches> I will be pushing
+23:07 < matches> 8 hours in the future
+23:07 < matches> I really should fix my system clock
+23:07 < matches> One of these days...
+--- Day changed Mon Sep 01 2014
+17:05 < matches> The wobbly lines on things are irritating me
+17:10 < matches> There doesn't seem to be anything wrong with Bresenham, which means the actual line endpoints are wrong
+17:11 < matches> The GPU does everything from floats and magically they go to the right spot in the buffer
+17:11 < matches> The CPU has to calculate integer pixel coordinates
+17:16 < matches> I need a magnifier I can't see the pixels that are in the wrong spot
+17:16 < matches> I know they are there
+17:21 < matches> ... ok maybe the Bresen Ham was a little past its use by date
+19:48 < matches> The more I try and get these lines to not look dumb, the more convinced I become that glDrawLines is doing something fancy
+19:56 < matches> You end up with wiggles in the line because the end points round to a different pixel to what you end up at by drawing the line
+19:57 < matches> If you make sure you start from where the last line ended, you still get a bend because of the left over error from the last line
+19:58 < matches> ...
+19:58 < matches> Drawing a single line when you know the Bezier is actually a single line is probably going to be less rage inducing than trying to fix this
+21:01 < matches> The Beziers are now classified according to Loop and Blinn
+21:01 < matches> Well
+21:01 < matches> Maybe
+21:01 < matches> It at least knows what lines are
+21:01 < matches> ...
+21:02 < matches> Ok all the ttf beziers are SERPENTINE and LOOP so that's probably wrong
+21:43 < matches> Ah, floating point precision strikes again
+21:43 < matches> That's kind of annoying
+21:47 < matches> But I suppose it's relevant
+21:47 < matches> Unless I'm totally screwing something up
+21:48 * matches adds in arbitrary fabs(x) < 1e-6 checks
+21:58 < matches> On the other hand, if you use DeCasteljau and stop the sub dividing whenever you get to something that classifies as a line, it's actually pretty cool
+21:59 < matches> But if you zoom in too far it starts to get classifications totally wrong
+22:02 < matches> Yeah I have an abstract due in 2 weeks
+22:02 < matches> so screwed
+--- Day changed Tue Sep 02 2014
+13:42 < matches> Ok, let's not use floating point values for colours
+13:42 < matches> Baad
+13:43 < matches> Bad bad
+13:43 < matches> Bad sheep
+13:43 < matches> The project isn't about precision of representable colours
+13:44 < matches> So I'm perfectly OK with using uint8 for colour components
+18:53 < matches> Is it too late to change the aim of the project to "render svg-tests/fox.svg but without antialiasing"
+18:54 < matches> "Or using the GPU"
+18:55 < matches> Well, I understand why shading doesn't usually use flood fill now anyway
+18:55 < matches> But I still kind of think flood fill is better at high resolutions
+18:56 < matches> Not parallelisable I guess
+18:56 < matches> ... Or is it
+18:57 < matches> I was going to try and do arbitrary precision stuff but it seems we can no longer compile unless Real == double or float
+--- Day changed Wed Sep 03 2014
+17:26 < matches> It would seem Mr Munroe has beaten us...
+17:28 < matches> In Javascript
+17:28 < matches> We should die of shame
+17:29 < matches> Hahaha
+17:29 < matches> "// there is no elegance here. only sleep deprivation and regret"
+17:31 < matches> On the bright side, we now have a reason to reference xkcd
+17:31 < matches> I guess?
+17:59 < sulix> I just saw that, and had planned to use that comment as my next commit message.
+--- Day changed Thu Sep 04 2014
+10:59 * sulix sulix also engages panic mode.
+11:00 * sulix apparently also needs to engage sleep mode.
+11:00 * sulix almost engaged sheep mode by mistake.
+11:49 < sulix> How sure are you that SolveCubic works?
+18:37 < matches> Well, sure within 1e-4
+19:40 < matches> Rational<Gmpint> compiles again
+19:41 < matches> It just takes... several minutes... to load "The quick brown fox jumps over the lazy dog"
+21:04 < matches> I have a new ingenius plan
+21:06 < matches> This will probably not work but hopefully it won't take me too long...
+21:06 < matches> Oh dear what am I saying
+21:06 < matches> It's going to take a month now
+22:24 < matches> I really should be integrating one of those two libraries Rowan suggested into the project
+22:24 < matches> As opposed to implementing what I like to call the "Paranoid Number"
+22:25 < matches> It starts as a float
+22:25 < matches> It checks each operation for an exception, and if it does it adds the operation to a linked list instead
+22:25 < matches> After trying to simplify the next elements in the list
+22:26 < matches> This is going to be awful
+22:26 < matches> But it's been a while since I wrote a good linked list
+22:32 < matches> ... I think the last linked list I wrote had a nasty tendency to randomly segfault...
+22:32 < matches> Nevertheless we shall forge ahead
+23:14 < matches> You know you haven't had enough sleep when you start to terminate lines with ':' instead of ';'
+23:14 < matches> I blame python
+23:14 < matches> Not that it was valid python syntax either
+23:15 < matches> But it's a good scapesnake
+23:42 < matches> Oh recursive list based functions
+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
+--- Day changed Wed Sep 24 2014
+12:33 <@matches> Ok, sulix do you want to help design these comparisons that we were going to use
+12:35 <@matches> We've got the "qualitative" comparisons pretty well...
+12:36 <@matches> It's the other 4 things
+12:36 <@matches> Performance vs number of primitives
+12:36 <@matches> Like
+12:36 <@matches> Do we add N primitives randomly?
+12:36 <@matches> Are our "test" documents just going to be Humphrey The Rabbit and Shady the Fox
+12:36 <@matches> Not that I have any objection to using them
+12:36 < sulix> I think so.
+12:36 <@matches> I'll add Emma the Cat and Mitch the Panda
+12:37 < sulix> Number of primitives should just be number of curves/objects.
+12:37 < sulix> I could do with some panda-monium. :P
+12:37 <@matches> Pommers beat you to that one
+12:37 <@matches> That's the name of the club's panda
+12:38 <@matches> I don't think I'll add Sam the Girraffe
+12:38 <@matches> It's embarrassing
+12:38 <@matches> Oh also did you read the wall of text?
+12:39 <@matches> Because I think we need a new way to demonstrate how much better the quad tree is than regular floats other than just zooming forever
+12:39 <@matches> Regular floats do quite well now
+12:39 <@matches> I should probably commit this
+12:39 < sulix> What about adding objects?
+12:39 <@matches> I also tried to get it to run without X for bus purposes
+12:39 <@matches> Well
+12:40 <@matches> Basically I threw out the idea of the view and just applied the transforms directly to all the object bounds
+12:40 <@matches> It will still print the equivelant view coordinates
+12:40 < sulix> Can you zoom out and then back in again?
+12:41 <@matches> I suspect if you go far enough there will be issues
+12:41 <@matches> The problem is going far enough takes a long time
+12:41 <@matches> We need to make ipdf take input so we can automate it?
+12:41 * sulix will do that this afternoon.
+12:41 <@matches> Or implement a "tester" that does it
+12:42 <@matches> HFP has a chapter on reducing error which boils down to rearranging the operands
+12:43 <@matches> Although they don't have anything as insanely dumb as ParanoidNumber
+12:43 < sulix> Isn't that what ParanoidNumber does?
+12:43 <@matches> Yeah
+12:43 <@matches> But ParanoidNumber doesn't assume any knowledge over what you are trying to do
+12:43 <@matches> Hence it is horribly inefficient
+12:44 < sulix> I suspect we need to sit down with Kahan and work out what the exact mathematical properties of floating-point error.
+12:44 <@matches> Their examples are like "If you know you are going to sum all these numbers, you sort them"
+12:44 <@matches> HFP goes through them
+12:45 <@matches> Sometimes you can represent the error as another float but with twice the precision?
+12:45 <@matches> It might be worth looking at whether MPFR includes the "Inexact" exception
+12:45 <@matches> Then you could just double the precision every time it occured?
+12:46 * sulix will be back shortly.
+12:47 <@matches> It's going to be a fun study break :S
+12:54 <@matches> Also PN manages to pass realops but somehow give totally whack behaviour when you actually use it
+12:54 <@matches> ...
+12:54 <@matches> And this is enforcing a size limit of "0" (which means it should just be equivelant to doubles!)
+12:55 <@matches> Also I should probably also write a draft thesis
+12:55 <@matches> Also other units suck, why can't the project count as 4 units
+12:56 <@matches> I'm finally starting to understand this properly, as we are running out of time at an alarming rate
+12:56 <@matches> I guess there probably won't be any experts on floating point arithmetic at my conference so I can probably pretend I know things
+13:02 <@matches> http://szmoore.net/ipdf/i-think-there-might-be-a-slight-maths-error-rabbit.png
+13:03 <@matches> I strongly suspect Copy/Paste errors
+14:07 < Pommers> Yeah. We have a club Panda
+14:10 -!- matches changed the topic of #ipdf to: IPDF: Infinite Panda Document Format
+14:13 <@matches> Um
+14:13 <@matches> cat.svg causes a segfault
+14:23 <@matches> It has an empty path?
+14:23 <@matches> I regret somewhat making the path be from m_start to m_end *inclusive*
+14:37 <@matches> Have a git push
+14:37 <@matches> Possibly with a correct timestamp
+14:47 <@matches> Ok, things still go whack when you apply transforms to objects instead of the view
+14:48 <@matches> But because you can add objects in screen space rather than converting to view space and back, you don't get the precision issues adding a new object
+14:48 <@matches> I suspect
+14:48 <@matches> If you add a new object at say 1e-6
+14:48 <@matches> It looks fine
+14:49 <@matches> Then you zoom back out to 0.5,0.5,1,1 or something
+14:49 <@matches> Then zoom back in
+14:49 <@matches> It *should* look all wierd again
+14:49 <@matches> Then again it might not
+14:49 <@matches> Because floating point errors are crazy
+14:51 <@matches> It does!
+14:51 <@matches> YES
+14:52 <@matches> It looks totally screwed up in a different way
+14:52 <@matches> So, I guess this just makes it more important that you can actually add elements to the quad tree
+14:53 * sulix feels the pressure mounting.
+14:54 <@matches> Is the quad tree kind of equivelant to applying the transformations to the objects but making sure you don't lose the original bounds
+14:54 <@matches> When you zoom back out you get the original bounds back
+14:54 < sulix> Yeah, largely.
+14:54 <@matches> Cool
+14:54 <@matches> I'm sure someone trained in maths can say smart stuff about that
+14:55 <@matches> Applying transformations to the object bounds is probably the best way if you have an arbitrary precision number representation
+14:55 <@matches> You can use a lower precision representation when you work in screen space then
+14:55 <@matches> Although I'm not sure how I would actually implement that...
+14:56 <@matches> With some kind of
+14:56 <@matches> Quad tree...
+14:56 <@matches> maybe
+14:56 <@matches> I guess if two methods end up with the same pixels in the same spot then they are mathematically equivelant
+14:58 <@matches> You could also speed things up
+14:58 <@matches> If you exploited the Path bounds
+14:58 <@matches> Express all the beziers within a path relative to {0,0,1,1} then just apply your transformation to the path
+14:58 < sulix> This is a much better design.
+14:59 <@matches> Well that's sort of a compromise between transforming the view or transforming all the bounds
+14:59 < sulix> But it's sort-of too late to change it all now.
+14:59 <@matches> I think I might have to though
+14:59 <@matches> If I want to make GMPrat performant
+15:00 <@matches> Lets face it, I'm doing a better job at redesigning the document structure to be less terrible than I am at actually implementing arbitrary precision number types :S
+15:01 <@matches> I could probably redesign the CPU renderer, but the GPU renderer would be harder
+15:01 <@matches> PathRenderer already does everything BezierRenderer does, but it adds shading
+15:02 <@matches> I think right now I will try to stop PN from being quite so broken
+15:02 <@matches> I am perplexed
+15:03 <@matches> As there is basically an "assert(equivelant to double)" after every single operation
+15:03 <@matches> None of them fail
+15:03 <@matches> And it gives a totally wrong result
+15:45 <@matches> It is rendering at 666 FPS
+15:46 <@matches> :O
+16:49 <@matches> Ok
+16:49 <@matches> There should be postive paranoid numbers soon
+16:49 <@matches> s/postive/negative
+16:49 <@matches> That thing that happens when you put a '-' sign in front of a number
+16:49 <@matches> Very important
+16:50 < sulix> Negative _and_ paranoid? I'm waiting for the "Number Theropy" classes next... :P
+16:50 <@matches> I've learned some valuable lessons about implementing number classes I guess
+16:50 < sulix> At least it isn't complex?
+16:50 <@matches> Make sure you test every single function against doubles
+16:51 <@matches> (Including constructors)
+16:51 <@matches> I'm really over bug fixing this class
+16:51 <@matches> I just want to make it faster dammit
+16:51 <@matches> I have ideas about how to make it faster
+16:53 <@matches> Admittedly they are mostly not good ideas
+16:53 <@matches> I'm expecting the arena may help more when I don't enforce a size limit of zero though
+16:54 <@matches> YES
+16:54 <@matches> I can render a paranoid rabbit
+16:54 <@matches> Oh wait
+16:54 <@matches> I didn't increase the size limit from zero
+16:54 <@matches> That will be the real test...
+17:02 <@matches> So are you going to implement a magical automated zoomer? :P
+17:03 <@matches> We kind of need to be able to choose what point to zoom in on depending on the particular test svg though :S
+17:04 <@matches> Right now it's hard to tell whether I am getting precision issues or I just accidentally moved the mouse a bit
+21:02 < sulix> That's about the most terrifying email it's possible to get, I think.
+21:59 < sulix> Very simple scripts for automating actions now exist.
+--- Day changed Thu Sep 25 2014
+08:27 < sulix> matches: Thoughts on a meeting time?
+10:58 <@matches> Ah
+10:58 <@matches> I sort of slept in
+10:59 <@matches> Well actually I didn't sleep in I just started practicing the piano and then it was 2 hours later...
+10:59 <@matches> Yeah that's a pretty terrifying email
+11:05 <@matches> I am excited by the script
+11:06 < sulix> Cool. I just added support for toggling some things to it.
+11:06 < sulix> When's best for you meeting-wise?
+11:06 <@matches> I can't make 11:15
+11:06 <@matches> Was there any other time that wasn't 5:45pm?
+11:07 <@matches> It'll be a struggle to make 9am
+11:07 <@matches> In fact apparently it's 7pm now
+11:07 <@matches> I must have really overslept
+11:07 <@matches> I'm sure I made progress this week
+11:07 <@matches> I just can't remember what it was
+11:07 < sulix> Well, I can make any time after ~12:00, now.
+11:08 < sulix> You did the whole cumulative transforms thing.
+11:08 <@matches> Yes, I'm not sure whether that was good or not
+11:08 <@matches> It sort of invalidates a whole bunch of earlier things
+11:09 <@matches> It is probably the only way that arbitrary precision bounds will ever be practical though
+11:09 <@matches> I also fixed ParanoidNumbers a bit I guess
+11:09 <@matches> But they are still terrible
+11:09 <@matches> I doubt it will get to the point where they ever aren't terrible
+11:12 <@matches> Do I do my GENG4402 assignment that's due on Friday or do I sacrifice it for the glory of IPDF?
+11:13 < sulix> I was going to say "IPDF is not a cult", but I'm not so sure.
+11:16 <@matches> On the one hand I feel sorry for you because you have the entire trip to Sydney as a meeting time
+11:16 <@matches> On the other hand I feel sorry for me because I haven't actually achieved anything
+11:17 <@matches> I have an abstract that says what I'm going to achieve...
+11:17 <@matches> It hasn't been achieved
+11:17 <@matches> Achievements are locked
+11:18 * sulix hasn't achieved anything but the scripting stuff in the last week. :/
+11:19 <@matches> You have a quad tree!
+11:19 <@matches> Did I tell you, GMPrat takes 5 seconds to pass tests/addsub and doubles take 5ms
+11:20 <@matches> Wait GMPrat was only 500ms
+11:20 <@matches> PN was 6 seconds
+11:20 <@matches> When restricted to size 1
+11:20 <@matches> There's a bug somewhere
+11:22 <@matches> They seem to grow a lot bigger than the size limit
+11:22 <@matches> Ah, probably because I don't check "m_size + b->m_size"
+11:27 <@matches> -_-
+11:27 <@matches> You need to stop adding Debug messages that assume Real is a double
+11:27 <@matches> :P
+11:28 <@matches> Some of us are trying to compile with other number representations here
+11:29 <@matches> I guess it does seem to actually work even though it's horrendously slow
+11:29 <@matches> That's an achievement of some sort
+11:30 <@matches> GMPrat also works and is horrendously slow but less horrendously slow, but I didn't actually invent that representation
+13:45 <@matches> The script has loadsvg now
+13:45 <@matches> It's tempting to make it turing complete... like some kind of... Post... Script
+13:45 <@matches> But that would be silly
+13:50 <@matches> I am loving this script thing
+13:50 <@matches> Think of all the calories I can save
+13:51 <@matches> My goodness I can even eat food whilst watching it zoom
+13:51 <@matches> My hand is freed
+13:51 <@matches> Freed from the tyranny of endless zooming
+13:56 < sulix> Cool: I was going to add loadsvg, but it still has some quadtree problems.
+13:58 <@matches> I think I will add "label" and "goto" so that I can zoom into the rabbit's eye *forever*
+13:58 <@matches> Well
+13:58 <@matches> Hmm that's actually work
+13:58 <@matches> But I still think it's necessary
+13:59 <@matches> You need to see at which point the Quad tree breaks
+13:59 <@matches> Note that we don't need it for anything I've done because everything I've done breaks before single precision floats
+13:59 <@matches> :(
+14:10 <@matches> I have just implemented goto
+14:10 <@matches> However there is still time to rename it to "goat"
+14:11 <@matches> Once you have a goto you really need a branch...
+14:15 <@matches> Go GMPrat
+14:15 <@matches> A mighty 3 FPS
+14:16 <@matches> The downside of my hands being free is I can type more things into IRC
+14:17 <@matches> You can do it GMPRat
+14:17 <@matches> Noo
+14:17 <@matches> 2.5FPS
+14:17 <@matches> We're still going strong
+14:18 <@matches> Oh that's the total accumulated average
+14:18 <@matches> It's actually at 0.8 FPS now
+14:18 <@matches> And falling rather dramatically
+14:20 <@matches> The fundamental flaw with these arbitrary precision types is the representation never gets smaller
+14:21 <@matches> GMP rationals would calculate the GCD which could get smaller (when you zoom back out for example)
+14:21 <@matches> But the GMP integer representation will still only ever increase in size
+14:21 <@matches> I think they just always use the largest precision
+14:22 <@matches> I was hoping that ParanoidNumber would do better since it actually has the ability to shrink
+14:22 <@matches> But it's not amazing
+14:22 <@matches> Hmm, I seem to have lost the rabbit
+14:22 <@matches> That's not meant to happen
+14:22 <@matches> GMPrat is supposed to be exact
+14:22 <@matches> Where did he go!
+14:34 <@matches> Every frame is agonising
+14:39 <@matches> Maybe it's time to switch to motsugo for CPU rendering tests
+14:40 < sulix> At least we now have a good way of burning up time in meetings?
+14:44 <@matches> I'm somewhat confused
+14:44 <@matches> With the cumulative transforms, the GPU renderer should work
+14:44 <@matches> (It is equivelant to using CPU for transformations)
+14:44 <@matches> But it seems to still break around 1e-6
+14:44 < sulix> Yes...
+14:45 <@matches> Oh
+14:45 <@matches> Right I commented out the TRANSFORM_OBJECTS_NOT_VIEW line
+14:45 * matches tries again...
+14:45 * sulix is really regretting the 4-switch statement, 16-case recursive function in the quadtree at the moment.
+14:46 <@matches> I'll make a deal, I won't look at quadtree.cpp if you don't look in paranoidnumber.cpp
+14:47 < sulix> Fair enough.
+14:49 <@matches> I'm not seeing anything in the GPU renderer past 1e-7
+14:49 <@matches> With GMPrat
+14:50 <@matches> I think I'm going to have to go through and fix the more obviously terribly designed parts of things
+14:50 <@matches> For GMPrat to have any chance
+14:53 <@matches> I'm wishing I had a quad tree so I didn't have to transform the bounds of things that would end up outside the screen space :P
+14:53 <@matches> Maybe there's hope for an unholy union of Quadtree and GMP rationals yet
+14:56 < sulix> "And the fifth angel sounded, and I saw a star fallen from heaven to earth: and to him was given the key to a bottomless abyss."
+15:00 <@matches> I think the GMP rational -> float conversion is fith?
+15:00 <@matches> It doesn't make any sense :S
+15:00 <@matches> An object that is visible should always have bounds somewhere in {0,0,1,1}
+15:00 <@matches> Which should be totally fine
+15:01 <@matches> Oh
+15:01 <@matches> Is this the bit where I made GMPrat::ToDouble return 0 if it was too big...
+15:02 <@matches> No it returns mpq_get_d
+15:02 <@matches> Blergh
+15:03 < sulix> An object which is visible should have bounds that _intersect_ {0,0,1,1}
+15:03 < sulix> Perhaps not contained within {0,0,1,1}
+15:03 <@matches> Yeah that
+15:04 <@matches> Maths
+15:04 <@matches> 0 <= x <= 1
+15:04 <@matches> No not that
+15:04 <@matches> Thing
+15:04 < sulix> Unless you're using the Quadtree, which does clip everything to {0,0,1,1}
+15:04 <@matches> Anyway
+15:04 <@matches> It should work
+15:05 <@matches> Wait
+15:05 <@matches> There is this blen thing in the shader
+15:05 <@matches> Is that passed via the view width or something
+15:05 <@matches> Hmm
+15:05 < sulix> That's kinda FITH.
+15:07 <@matches> Anyway, somehow there is a multiplication by width/height and then probably a division afterwards somewhere else
+15:07 <@matches> I'm rather confused
+15:09 * matches struggles to navigate the treacherous waters of view.cpp
+15:10 <@matches> That's right, RenderRange does the actual things
+15:10 <@matches> We've got PrepareRender -> Render -> RenderRange/QuadtreeNode
+15:11 < sulix> RenderQuadtreeNode just calls RenderRange a bunch of times and then breaks the document.
+15:13 <@matches> It's alright, we can save to bitmap, we don't need the document structure to not break
+15:13 <@matches> So how the hell is the shader getting rounding errors
+15:13 <@matches> It should always get glbounds of {0,0,1,1}
+15:13 <@matches> (With cumulative transforms)
+15:15 <@matches> Then RenderRange -> ObjectRenderer::RenderUsingGPU...
+15:17 <@matches> This does not make sense
+15:17 <@matches> Things cannot be broken in this way such that they work
+15:18 <@matches> Hello
+15:18 <@matches> GraphicsBuffer::BufferUsageStaticDraw
+15:18 <@matches> Does that do a thing?
+15:19 <@matches> Also
+15:19 <@matches> Should //m_objbounds_vbo.Invalidate(); be commented out
+15:19 <@matches> I'm still confused as to how it works at all
+15:20 < sulix> BufferUsageStaticDraw tells the driver that we're not planning to modify this buffer frequently.
+15:21 < sulix> The Invalidate() stuff should be commented out, IIRC.
+15:23 <@matches> Hmm when in doubt make clean
+15:30 <@matches> Anyway
+15:30 <@matches> I hope you get the quadtree working with adding stuff
+15:30 <@matches> Because the only point at which doubles fail is when they get a sigfpe
+15:31 <@matches> Floats do start to do strange things before that
+15:32 <@matches> Actually no, doubles would screw up it's just the script is not testing in that range
+15:33 < sulix> I'm still trying to get panning working with the quadtree at the moment.
+15:33 < sulix> I was scratching my head for quite a while before I realised TRANSFORM_OBJECTS_NOT_VIEW was on.
+15:34 <@matches> Sorry
+15:34 <@matches> It really helps the non quad tree rendering
+15:34 < sulix> (You'd be surprised how totally it breaks the quadtree)
+15:34 <@matches> Oh I'm not that surprised
+15:34 <@matches> The quad tree is basically doing cumulative transforms after all
+15:34 <@matches> In a very loose sense
+15:35 < sulix> The quadtree does both.
+15:35 < sulix> It's an equal-opportunity data structure.
+15:37 <@matches> The more I think about this, the more I am convinced the quadtree is the only sensible solution
+15:37 <@matches> Which is unfortunate
+15:37 <@matches> I had hoped to actually have something to present
+15:37 <@matches> Other than "And you should all attend my partner's presentation next week!"
+15:38 <@matches> I guess I should produce some performance graphs or something
+15:38 <@matches> What I did was a terrible idea and this is why
+15:39 <@matches> Sort of thing
+15:40 <@matches> I wonder where the bottleneck is though
+15:40 <@matches> GMPrats get very slow even with the GPU renderer
+15:40 < sulix> Converting to doubles?
+15:40 < sulix> Doing gcd() all day?
+15:40 <@matches> Maybe
+15:40 <@matches> gcd is 50% of execution time according to perf
+15:41 <@matches> perf is pretty cool but it is not as easy to use as valgrind
+15:41 <@matches> Unfortunately valgrind doesn't fully emulate the FPU
+15:41 <@matches> So ParanoidNumbers don't work at all using it
+15:42 <@matches> Which is very frustrating because there have to be things I can speed up in them
+15:42 <@matches> I have a git stash where I tried to implement Copy-On-Write but it was a bit of a disaster
+15:42 <@matches> It was so much of a disaster that even with COW disabled they still broke (despite working fine in the previous commit...)
+15:43 <@matches> They do spend an excessive amount of time copy constructing each other though
+15:50 <@matches> If I can express bezier bounds relative to the containing path it might speed things up slightly
+15:51 < sulix> Ideally we'd ditch the "BEZIER" object and just have paths.
+15:51 < sulix> But that sounds like a lot of work.
+15:53 <@matches> I'd be less inclined to want to do it if things weren't so amazingly slow
+16:00 <@matches> It looks like Bezier::GetType is slowing the CPU rendering down at least
+16:01 <@matches> Clearing pixels is also slow
+16:01 <@matches> Although that doesn't depend on the zooming
+16:02 <@matches> GPU rendering isn't much better though, hmm
+16:46 <@matches> The Arena sort of helps things
+16:47 <@matches> Until it gets to allocating 40 million x 180 Bytes ...
+17:25 <@matches> Protip, #define and spelling mistakes and #ifdef do not work together well...
+--- Day changed Fri Sep 26 2014
+01:40 <@matches> I came up with a compromise between not doing GENG4402 to work on IPDF and doing GENG4402
+01:40 <@matches> The only casualty was sleep
+01:41 <@matches> And no one likes him anyway
+01:41 <@matches> All sides were pleased by the deal
+16:21 * matches regrets upgrading debian jessie after the shellshock thing
+16:21 <@matches> fglrx is gone again
+--- Day changed Sat Sep 27 2014
+12:28 <@matches> 5 minutes to go in ACM...
+12:29 <@matches> You can do it Dijkstras on Bijkstras
+12:30 <@matches> Oh 5 minutes until they freeze the score board
+12:30 < Pommers> 5mins? Timer says an hour
+12:30 <@matches> Apparently they freeze the score board
+12:30 <@matches> I don't know how these work
+12:30 <@matches> I only just started watching
+12:31 <@matches> An hour is plenty of time
+12:31 < Pommers> So teams can't see each others scores change?
+12:31 <@matches> Yeah
+12:31 <@matches> Mickelback just got C wrong
+12:31 < Pommers> They secretlyu have them all solved and are just waiting to waste time
+12:31 <@matches> Yes
+12:31 <@matches> Nice camera work...
+12:31 < Pommers> Getting it right won't get them into first though
+12:32 <@matches> I can't see them
+12:33 < Pommers> UWA needs labs like that
+12:33 <@matches> It's still anyone's game!
+12:33 <@matches> They said it
+12:33 <@matches> You can do it Dijkstras on Bijkstras
+12:33 < Pommers> Cmon Dijksras in Kijkstras
+12:34 * Pommers fails
+12:34 <@matches> Go for G
+12:35 < Pommers> Yeah. Be the winner and Get G right now
+12:35 <@matches> Also D
+12:35 <@matches> and E
+12:35 < Pommers> B D E G
+12:35 <@matches> All you need to do is get all the hard ones right without anyone else getting them right...
+12:35 < Pommers> Nah
+12:36 < Pommers> You want to get all the easy ones as soon as possible
+12:36 < Pommers> Then work out the harder ones
+12:36 <@matches> It's a bit late now..
+12:36 <@matches> Sink everything into the hard ones!
+12:37 < Pommers> The teams still get feedback in the last hour right?
+12:37 <@matches> I assume so
+12:37 <@matches> This camera is totally biased
+12:37 <@matches> I haven't seen sulix yet
+12:37 <@matches> Just shots of people eating sandwiches
+12:38 < Pommers> Sandwich eating stream
+12:38 < Pommers> Best Stream
+12:39 < Pommers> I saw Rowan before
+12:39 <@matches> ANU is doing well
+12:39 <@matches> I think this calls for some sabotage
+12:40 < Pommers> Where's axtens when we need him
+12:40 <@matches> In Canberra
+12:40 <@matches> Also he'd probably be supporting ANU
+12:41 < Pommers> Probably
+12:42 <@matches> I'm waiting for it to all come together
+12:42 <@matches> And all the boxes to turn blue
+12:42 <@matches> Commentator is a bit behind
+12:42 < Pommers> So they've submitted but no public feedback
+12:42 <@matches> Or the stream is a bit behind I guess
+12:42 < Pommers> 45 seconds
+12:42 <@matches> ANU made that submission 3 minutes ago
+12:43 <@matches> Singing!
+12:43 <@matches> This stream has it all
+12:43 < Pommers> I have the stream muted
+12:43 <@matches> Ooh a shot of the other room
+12:44 <@matches> sulix: Stand up!
+12:44 < Pommers> Move out the way so we can see into the room
+12:44 < Pommers> up and down the bolevard
+12:44 <@matches> Hahaha
+12:45 <@matches> That *could* be sulix in the background
+12:47 <@matches> I guess it would be intrusive to have the camera in the room with the contestants
+12:47 <@matches> Also for 14 viewers
+12:48 <@matches> I love the sign off
+12:51 <@matches> Gozz!
+12:51 <@matches> Gozz what are you doing!
+12:51 <@matches> Get back to the desk!
+12:54 <@matches> These coaches(?) look rather worried
+12:55 <@matches> Oh well, I guess I should actually work on IPDF
+12:55 <@matches> Not all of us get free trips to Sydney :P
+13:00 < Pommers> So yeah. They get there own score line
+13:01 < Pommers> I missed Gozz!
+13:03 <@matches> They must be doing well if they have time for sandwich breaks
+13:03 <@matches> Have all the solutions ready to submit in the last 5 minutes
+13:03 <@matches> Shock victory
+13:03 < Pommers> Or they have given up
+13:03 <@matches> No!
+13:03 <@matches> How do you read the scores anyway?
+13:03 <@matches> The first column is number of problems solved
+13:03 <@matches> What's the second
+13:04 < Pommers> I explained in #ucc before
+13:04 <@matches> Ah damn
+13:04 < Pommers> 12:09 <@Pommers> Ranking is number of challanges sorted: More is better
+13:04 < Pommers> 12:09 <@Pommers> Numeric number: Less is better
+13:04 < Pommers> 12:09 <@Pommers> Cause the number is minute challenmge was solved + 10 * number of failed attempts
+13:04 < Pommers> 12:10 <@Pommers> 20, not 10
+13:04 <@matches> I thought they were doing well because they had a high number
+13:04 < Pommers> 12:10 < bob> so those teams who haven't finished anything and have a score of zero are winning?
+13:04 < Pommers> 12:11 < bob> oh I get you now
+13:04 < Pommers> 12:11 <@Pommers> Nope. Because number of challenges sorted is more important
+13:04 < Pommers> 12:11 < bob> really shittily labeling on that table
+13:04 < Pommers> 12:11 < bob> so mickelback is coming second
+13:04 <@matches> Yes yes I can change windows
+13:04 < Pommers> 12:11 <@Pommers> The numbers on the left show their current position
+13:04 < Pommers> 12:11 <@Pommers> Yep
+13:04 < Pommers> 12:12 <@Pommers> The scoring system is pretty much the same for all coding competitions
+13:04 < Pommers> 12:12 <@Pommers> GCJ is different though
+13:04 < Pommers> 12:16 <@Pommers> Numbers down the bottom are attempts/correct/time was first solved
+13:04 < Pommers> Nope
+13:05 < Pommers> But now it's in your logs too!
+13:05 <@matches> Meh anything that skews the statistics away from me talking to myself is fine by me
+13:05 <@matches> Just copy paste all of #ucc in here please
+13:06 <@matches> Mikelback could still win
+13:06 < Pommers> 13:05 <@matches> Just copy paste all of #ucc in here please
+13:06 < Pommers> If you say so
+13:06 <@matches> Nonononono
+13:07 <@matches> I'
+13:07 <@matches> ll just delete the git repository when this is over
+13:08 < Pommers> Sounds like a good idea
+13:13 <@matches> So you can go back to earlier parts of the stream
+13:13 <@matches> "I tell you, in this life there are only two things to die for: Your country, and these sandwiches"
+13:15 < Pommers> Yep
+13:15 <@matches> Back to live action, and there is a close up of someone eating a sandwich
+13:27 <@matches> There's still time!
+13:28 <@matches> Why are things not turning blue
+13:29 <@matches> Mickelback appears to be struggling on B
+13:29 <@matches> Haha
+13:29 <@matches> "It could be anyone... anyone... well probably not Auckland Queensland or Adelaide"
+13:29 <@matches> Anyone of the top five
+13:31 <@matches> I'm still waiting for the 5 simultaneous submissions from Dijkstras on Bijkstras
+13:32 <@matches> More sandwiches
+13:34 < Pommers> Now we wait
+13:36 <@matches> Reading these logs back it sounds a lot wierder when you don't notice the timestamps
+23:23 <@matches> So, after much spaghetti bolognaise
+23:24 <@matches> I managed to perform the arbitrary precision transformations only on the bounds of paths as opposed to the bounds of every single object.
+23:24 <@matches> It helps a lot but at the end of the day it's still fantastically useless.
+23:24 <@matches> Project complete I guess.
+23:24 <@matches> Just Use Quad Trees
+23:25 <@matches> If I had some way to clip the objects to the view so I only had to transform things that would be shown...
+23:25 <@matches> I would have a quad tree
+23:25 <@matches> If I don't do that, then you still have the exponentially growing Gmprat
+23:26 <@matches> Oh
+23:26 <@matches> Oooh
+23:26 <@matches> Actually
+23:26 <@matches> I had the CPU renderer on
+23:27 <@matches> The GPU renderer loves this
+23:27 <@matches> The CPU renderer seems to generally just suck
+23:27 <@matches> I suspect there is actually a bug in it
+23:27 <@matches> It shouldn't be so slow
+23:28 * matches is getting really excited
+23:28 <@matches> I actually zoomed in to 1e-9 using floats for everything except the Path bounds
+23:29 <@matches> It would be nice the CPU renderer didn't suck, but I guess "Transform the bounds with arbitrary precision on the CPU and do rendering with floats on the GPU" is actually the better approach
+23:32 <@matches> Also... I think somehow I got an updated fglrx that is less shit at rounding floats
+23:32 <@matches> Because eye_of_the_rabbit doesn't go all funny anymore...
+23:32 <@matches> Unless you make it zoom a little bit more
+23:36 <@matches> I still think the quad tree will beat this in terms of performances
+23:36 <@matches> But at least it's like, in the game
+23:36 <@matches> As in it doesn't take so long to do the performance test that it's not worth bothering actually doing a comparison
+23:36 <@matches> Now we can have a graph at least
+23:46 < Pommers> Very nice
+23:51 <@matches> The CPU renderer is stalling in DeCasteljau
+--- Day changed Sun Sep 28 2014
+00:18 <@matches> sulix: You need to get eye_of_the_rabbit working under the quadtree so I can compare it with my horrible hacks to View,Path,BezierRenderer,PathRenderer...
+00:18 <@matches> Document...
+00:18 <@matches> Not a single class escaped the wrath of the #ifdef
+00:18 <@matches> No pressure, glhfdd
+00:19 <@matches> Unfortunately I still get a bunch of SIGFPEs but I think those are in places that don't affect the rendering, so I can probably fix them
+00:19 <@matches> Or set the program to ignore them
+00:20 <@matches> I never really worked out how you turned them on in the first place :S
+00:20 <@matches> Also well done at ACM and all that
+00:21 <@matches> The #define's you'll want to turn off to get the quadtree working again are both the ones in view.h and path.h
+00:21 <@matches> Oh wait I put in a check just for you
+--- Log opened Sun Sep 28 09:58:47 2014
+09:58 -!- Irssi: #ipdf: Total of 1 nicks [1 ops, 0 halfops, 0 voices, 0 normal]
+09:58 -!- Irssi: Join to #ipdf was synced in 0 secs
+10:04 -!- matches changed the topic of #ipdf to: Motsugo OOMed, this would be a great excuse to extend the project if we were actually using Motsugo
+--- Log closed Sun Sep 28 10:08:08 2014
+--- Log opened Sun Sep 28 10:08:20 2014
+10:08 -!- Irssi: #ipdf: Total of 1 nicks [1 ops, 0 halfops, 0 voices, 0 normal]
+10:08 -!- Irssi: Join to #ipdf was synced in 2 secs
+--- Day changed Wed Oct 01 2014
+15:13 <@matches> Urgh the code is disgusting
+15:13 <@matches> I can't look at it
+15:16 <@matches> The quadtree does some... interesting things
+15:17 < sulix> I think by "interesting," you mean "horrible."
+15:18 < sulix> ... or possibly "wrong"
+15:22 <@matches> Well, you appear to be able to add things to the document
+15:22 <@matches> They are just in the wrong spot
+15:22 <@matches> Also things seem to disappear as well
+15:28 <@matches> Also I can't seem to compile without the quadtree anymore
+15:29 <@matches> You're going to have to deal with the Makefile because I'
+15:29 <@matches> m moving quadtree.o out of the defaults
+15:29 <@matches> It expects things in IPDF::Document that won't exist if the quadtree is disabled
+15:35 < sulix> Oops...
+15:35 < sulix> I have started using the makefile, though, so that's good.
+15:39 <@matches> I'm somewhat regretting the use of Real in the Bezier
+15:39 <@matches> I need another Real
+15:39 <@matches> Real2 ?
+15:39 <@matches> Or I can do terrible hacks with #undef
+15:39 <@matches> Hmmm
+15:39 <@matches> Terrible hacks with #undef it is!
+15:40 <@matches> Possibly we need a seperate header for all these defines
+15:40 <@matches> I have #defines in path.h that only work if there is also a #define in view.h ...
+15:41 <@matches> But the #define in view.h will still work without the one in path.h
+15:43 <@matches> Possibly using different branches would have been cleaner
+15:43 <@matches> Possibly I should really stop writing code and start writing a report anyway
+15:43 <@matches> So many regrets
+15:44 <@matches> I explained the project to some Engineers today!
+15:44 <@matches> They understood it!
+15:44 <@matches> They questioned the point of it all...
+15:44 <@matches> I said "The point is that you can zoom into this point here..."
+15:44 <@matches> "And it turns into a rabbit!"
+15:44 <@matches> :S
+15:46 <@matches> Also "Why isn't there any shading"
+19:24 <@matches> I'm having a little trouble with the performance metrics
+19:24 <@matches> How do I pick something that is a legitimate performance metric
+19:24 <@matches> "We decided to render this Fox and this Rabbit"
+19:25 <@matches> Also I really wish ipdf were good enough to do the report in it, because then it could demonstrate itself
+19:25 <@matches> Now I have to link to a video?
+19:26 <@matches> I mean
+19:26 <@matches> "Figure 1 is the rabbit and Figure 2 is the rabbit that looks exactly the same when you zoom in!"
+19:26 <@matches> Is not really impressive
+19:26 <@matches> "Figure 1 is the rabbit and Figure 2 is the rabbit that looks terrible when you use floats and you'll just have to trust us when we say we fixed this"
+19:26 <@matches> :S
+19:28 <@matches> Also causing difficulty...
+19:28 <@matches> The zoom level I am at is not representable as a double
+19:28 <@matches> Which means it cannot be plotted in gnuplot unless I scale it to the range of doubles first...
+19:28 <@matches> Which sort of defeats the point...
+19:29 <@matches> I guess I could plot "Exponent"
+19:29 <@matches> If you clear the document after every 3 rabbits, eye_of_the_rabbit appears to go for a very long time
+19:30 <@matches> So that's the performance vs zoom I guess
+19:30 <@matches> But only take a data point after every 3 rabbits otherwise you are also altering number of primitives
+19:30 <@matches> Panning is pretty much the same
+19:33 <@matches> I'm just going to sit and watch it zoom for a while I guess
+19:33 <@matches> Mesmerising
+19:34 <@matches> Should I help fix the quad tree?
+19:34 <@matches> I'd like to be able to compare it to the "actually we'll only use arbitrary precision for *some* things" approach
+--- Log opened Thu Oct 02 13:55:13 2014
+13:55 -!- Irssi: #ipdf: Total of 1 nicks [1 ops, 0 halfops, 0 voices, 0 normal]
+13:55 -!- Irssi: Join to #ipdf was synced in 3 secs
+14:44 <@matches> Hello
+14:44 <@matches> Are we having a meeting today?
+14:45 < sulix> Rowan is still in Sydney.
+14:45 <@matches> Oh
+14:45 <@matches> That would make it difficult
+14:45 <@matches> Well, I'
+14:45 < sulix> (Also every time I touch the quadtree it ends up more broken)
+14:45 <@matches> m in UCC trying to actually get some sort of performance graphs
+14:45 <@matches> :(
+14:46 <@matches> Yeah, it turns out Gmprat may beat floats considerably but it isn't that great compared to doubles
+14:46 <@matches> It's interesting actually
+14:46 <@matches> It only really starts to slow down right at the limit of double precision
+14:46 <@matches> Then again, doubles will screw up before that (I hope)
+14:47 <@matches> You can represent 1e-38 with a float but it still screws up at 1e-6 after all
+14:47 <@matches> Also no one understands the eye_of_the_rabbit demo
+14:48 <@matches> I don't know why
+14:48 <@matches> It's pretty obvious it's *zooming to infinity*
+14:48 <@matches> (TM)
+14:48 <@matches> Righht?
+14:48 <@matches> :(
+14:48 < sulix> Their puny minds cannot contain the majesty that is eye_of_the_rabbit.script
+14:50 <@matches> A demo that actually added text where the text was the scale might be cool
+14:50 <@matches> Except debugscript is not that advanced
+14:50 < sulix> If you want to add string formatting to debugscript, I will not be involved. :P
+14:51 <@matches> I would probably just hack on a command
+14:51 <@matches> "Do this one particular demo"
+14:51 <@matches> Instead of making the scripting language turing complete...
+14:53 <@matches> In other news, Gozz taught me the difference between %d and %i :P
+14:53 < sulix> My greatest shame...
+14:54 <@matches> I normally use %d but I never actually realised they were differenc
+14:54 <@matches> Well they aren't when printf'ing
+14:55 < sulix> Four hours (+ an 80 minute penalty) because of random octal...
+14:55 <@matches> Well, if you'd won you wouldn't be able to finish IPDF
+14:57 < sulix> (Yeah, but maybe I'd've been good enough to not make the QuadTree horribly buggy...)
+14:58 <@matches> I should look at it
+14:58 <@matches> When I tried it, it was adding objects but they were appearing in totally whack places
+14:58 <@matches> Also different places depending on what renderer was used
+14:59 <@matches> I'm pretty much in favour of just focussing on the GPU renderer now though
+14:59 < sulix> At the moment it should only add things to the root node.
+14:59 <@matches> I have encountered the issues you mentioned where the CPU renderer suddenly decides to crash X
+15:00 < sulix> It seems to just suddenly start eating all of the ram in the world.
+15:00 <@matches> I don't know why though
+15:00 <@matches> It does it with regular floats as well
+15:01 <@matches> Unless it's allocating the pixel buffer every frame but why the hell would I have done that
+15:06 <@matches> Also! Really annoying! GMP can only print rationals as num/den
+15:06 < sulix> I guess that's because not all rationals have a finite decimal expansion.
+15:06 <@matches> It has Rational -> Double but not Rational -> Arbitrary Precision Double
+15:07 <@matches> Yeah, but I wish you could go "Print in scientific notation to 4 sig fig"
+15:08 <@matches> I resorted to log(a/b) = log(a) - log(b)
+15:08 <@matches> Except it doesn't actually have logarithm either
+15:08 <@matches> It has "Number of digits needed in base X"
+15:08 <@matches> Close enough...
+15:09 <@matches> Actually no it's awful
+17:32 <@matches> I'm going to have to do some disgusting template-yness things to Rect and Bezier I think
+17:47 <@matches> Blergh
+17:47 <@matches> Having a universal Real type is really damn annoying now that I don't want a universal Real type
+17:48 <@matches> I can do: template <struct T = IPDF::Real> struct Rect {...};
+17:48 <@matches> But then you have to replace Rect with Rect<> everywhere
+17:49 <@matches> I could make very single class a template class with Real as the template
+17:49 <@matches> Because that isn't horrifying
+17:52 * matches sobs and makes Rect a typedef for "TRect"
+18:22 <@matches> A is for ambiguous
+18:31 * matches curses templates
+18:31 <@matches> They attempt to solve the flaws in preprocessor macros by not actually solving anything
+18:32 <@matches> So that you will give up and just not write the program
+18:32 <@matches> The purpose of templates is to stop people from programming
+18:42 <@matches> Maybe don't pull the latest commit if you want anything to work at all
+--- Day changed Fri Oct 03 2014
+14:53 <@matches> The GMP attitude to logarithms seems to be "You can just write your own" which is nice, except that writing your own is not actually that easy to do well
+15:39 <@matches> This is rather annoying
+15:39 <@matches> When running the "Performance vs View Bounds" test, the bottleneck is in printing the View bounds
+15:40 <@matches> Because it requires a log of logs
+15:40 <@matches> *log of lots
+15:40 <@matches> *lot of logs
+15:40 <@matches> *lots of lumberjacks
+15:40 <@matches> *whatever
+15:41 <@matches> At least I seem to have made it O(1) where 1 is depressingly large constant
+15:55 <@matches> And so, after a day and a half, I can hopefully actually print bounds that are outside the range of representable doubles
+15:56 <@matches> Then I guess I'll have to do some kind of hack to get the "e-XXX" part so I can actually import them in numpy/gnuplot
+--- Day changed Sat Oct 04 2014
+13:55 <@matches> So, time investment
+13:55 <@matches> Do I make graphs
+13:55 <@matches> Or do I draw a turtle.svg
+13:55 <@matches> So that we can make the "Turtles all the way down" reference
+13:55 <@matches> Tough decision
+13:56 < Pommers> Turtles
+14:19 <@matches> I think fglrx must have a memory leak
+14:20 <@matches> Even after the program quits everything dies
+14:20 <@matches> And stays dead
+14:21 <@matches> Apparently I only have 80MB of memory left, yet the most anything in top is using is 100MB
+14:21 <@matches> ...
+14:21 <@matches> It's still decreasing
+14:21 <@matches> I have 10 MB left ?
+14:22 <@matches> Farewell
+14:26 < Pommers> glhfdd
+15:23 <@matches> http://szmoore.net/ipdf/code/src/svg-tests/turtle.svg
+15:23 <@matches> Can't be bothered colouring it in
+15:23 <@matches> It occurs to me that if we had recursive SVG support we would be Winning (TM)
+15:24 <@matches> I wonder how hard it would be to hack that on...
+15:24 <@matches> Need to map SVG "id" attributes to a Path
+15:24 <@matches> Need to allow Path to include Path
+15:24 <@matches> Hmm...
+15:24 <@matches> It's probably going to be as hard as shading
+15:25 <@matches> ie: Significantly harder than it should be due to the somewhat flawed design of our Object representations
+15:25 <@matches> We really only need Path and none of these other shaders
+15:26 <@matches> Maybe one Path shader per path too
+15:26 <@matches> As opposed to one Bezier shader for every single Bezier
+15:26 <@matches> Well, same shader but with different VBOs
+15:26 <@matches> Or IBOs
+15:26 <@matches> whatever
+15:28 <@matches> The problem is I can't implement Turtles all the Way Down in such a way that it shows all the turtles without either a) Making the DebugScript turing complete, or b) Implementing recursive SVGs
+15:29 <@matches> And option b) has the advantage of the document still being interactive whilst option a) restricts the view to what the script is doing
+15:30 <@matches> Also if the quad tree was working, turtles all the way down would be a good test of it, because the Arbitrary Precision bounds gets really slow since it has to always transform every path even those that are off screen
+15:31 <@matches> I should probably start writing a thesis but I really want to actually have something impressive to write about
+15:31 <@matches> I mean I still have to write about all the other stuff as well
+15:31 < Pommers> Yay off by one errors!
+15:32 <@matches> What, with the Log10 ?
+15:32 <@matches> It shouldn't be off by that much
+15:32 <@matches> Wait how are you running this
+15:32 <@matches> Wait you're talking about something else -_-
+15:32 < Pommers> Yes
+15:32 < Pommers> I've spent the past day looking for this error
+15:34 <@matches> Good job?
+15:34 < Pommers> Nope. So annoying. THought I just had it. Nope.
+15:35 <@matches> Sounds like we could make you an honarary IPDF developer
+15:35 < Pommers> I thought I already was :P
+15:38 < Pommers> Nope. Now my numbers are more off :/
+16:07 <@matches> Try ParanoidNumber
+16:07 <@matches> Guaranteed to give semi-accurate segfaults
+16:10 <@matches> Trying to look up some paper to justify my Logarithm approximation (because doing maths myself is hard)
+16:10 <@matches> "Computing discrete logarithms with the parallelized kangaroo method"
+16:10 <@matches> I... don't... even...
+16:11 <@matches> Why isn't there a paper on this
+16:11 <@matches> It shouldn't be hard, ergo, someone should have written a paper
+16:14 * matches really regrets only getting 60% in applied maths
+16:14 <@matches> I'm fairly sure this sort of thing was in it
+16:14 <@matches> Series approximations and stuff
+16:45 <@matches> Argahsdgf
+16:45 <@matches> It's actually hard to define what we *want* from our arbitrary precision document
+16:46 <@matches> Hmm
+16:46 <@matches> You have a view port, and you want primitives that are scaled to the view port to appear identical, regardless of where the view port is
+16:46 <@matches> Does that work
+16:46 <@matches> sulix are you alive
+16:46 <@matches> Is the quad tree going to be ok
+16:48 < sulix> Alive might be overstating it slightly. The quadtree is still kind-of functional.
+16:48 < sulix> (None of your commits have broken anything obvious, which is nice)
+16:49 * Pommers stabs floating point ints
+16:49 < Pommers> 0.0000000001 off
+16:50 <@matches> Most of my commits affect stuff that's wrapped in a bunch of #ifdef QUADTREE_DISABLED
+16:50 <@matches> I added some typedef's but they are all just equivelant to Real if QUADTREE_DISABLED
+16:51 <@matches> Pommers: Are you using floats or doubles? And if so, change to long doubles
+16:51 < sulix> That was very kind of you. I'm not sure how many drastic changes the quadtree can take at this point.
+16:52 < sulix> Was is SPARC that supported "quads"?
+16:52 <@matches> I'm kind of curious as to whether anything actually supports Base 10 floats
+16:52 < Pommers> Doubles
+16:52 < Pommers> I could try long doubles
+16:52 <@matches> Because it's in the standard
+16:53 <@matches> long doubles will probably help
+16:53 <@matches> I haven't run out software with long doubles yet because I'm really expecting it to do amazingly better than Gmp rationals
+16:54 <@matches> In theory, with enough memory, GMP rationals will win
+16:56 * matches suddenly realises just how much stuff there is that needs to be done
+16:57 * matches cries
+16:57 < Pommers> My great commit log... https://github.com/mpomery/CITS3402/commits/master
+16:57 * sulix sobs sympathetically
+16:58 <@matches> That has nothing on the IPDF commit logs I'm sorry
+16:59 <@matches> I should really stop deliberately making the commit messages over dramatic
+16:59 < Pommers> Probably not
+16:59 < Pommers> Definately
+17:01 < sulix> The more I think about the quadtree, the more certain I am that it should just be crashing all the time.
+17:10 * sulix quietly wonders if he can steal some code from that xkcd comic.
+17:18 <@matches> So, it only works if you give it a starting SVG because it loads the whole thing into the root node and then builds the other nodes as you zoom
+17:18 <@matches> And inserting things at some arbitrary point is hard
+17:18 <@matches> Could you... brute force... recreate the entire thing from the root node
+17:19 < sulix> The plan (after the great minus-sign move of '14) is to simply create a new document from wherever you add something, and "overlay" it.
+17:20 <@matches> Ah
+17:20 <@matches> sounds clever
+17:20 <@matches> Hmm
+17:20 <@matches> There's a whole bunch of definitions and obvious assumptions that I need to state
+17:20 <@matches> How do I even explain this
+17:21 <@matches> So, bresenham lets you draw a line exactly given the end points => You only care about rounding the end points
+17:21 <@matches> Bezier = decompose into Bresenham => You care about rounding in the Bezier decomposition
+17:21 < sulix> Well, bresenham doesn't let you draw a line exactly at all.
+17:21 <@matches> Pfft
+17:21 <@matches> Exactly shchmexactly
+17:22 <@matches> To pixel accuracy I guess
+17:22 <@matches> If the Bezier is in screen space and the buffer is small enough, then the bezier decomposition is accurate-enough to within the nearest pixel
+17:22 <@matches> So you care about transforming the bezier control points
+17:22 <@matches> They can be written relative to the bounds so you care about transforming the bounds
+17:23 <@matches> The bounds can be written relative to the path ergo you only need to transform the path bounds
+17:23 <@matches> Ergasdfadfg
+17:23 <@matches> It's all relative
+17:24 <@matches> There's no point being able to render something in bounds 1e-100000 if you don't also want to store something up at width 1
+17:24 <@matches> Otherwise you may as well just use bounds with width 1 and then do a multiplication before you printf them
+17:24 <@matches> Problem solved!
+17:29 <@matches> What I am trying to do makes perfect sense in my head and absolutely no sense translated to english
+17:29 <@matches> And translating it to maths is just asking for trouble
+17:29 < Pommers> #pragma omp single means that I'll start up a single thread to do something right?
+17:30 <@matches> Well, it won't create a new thread, it means a single thread out of the current pool will do it
+17:30 < Pommers> Okay. How can I get OpenMP to create a thread to do one of several for loops?
+17:31 <@matches> #pragma omp parallel for
+17:31 <@matches> Divides the loops up evenly amongst the threads
+17:31 <@matches> Is that what you want?
+17:31 < Pommers> Nah, multiple for loops, not the one
+17:32 <@matches> Is the loop inside a parallel secion already?
+17:32 < Pommers> Unless I am misunderstanding what parallel for does
+17:32 < Pommers> Nope, not inside a loop yet
+17:32 <@matches> Unless you explictly use a #pragma omp parallel, the code will be executed by the main thread
+17:33 < Pommers> So if I go:
+17:33 < Pommers> #pragma omp parallel
+17:33 < Pommers> #progma omp single
+17:33 < Pommers> for loop
+17:33 < Pommers> #progma omp single
+17:33 < Pommers> for loop
+17:34 < Pommers> #pragma omp barrier
+17:34 < Pommers> The for loops with get executed by potentially different threads?
+17:34 <@matches> Yes
+17:34 <@matches> And they only get executed once
+17:34 <@matches> But you can't predict the order
+17:34 < Pommers> Cool
+17:34 <@matches> Anything outside the "single" gets done by all threads
+17:35 <@matches> I don't think you need the barrier
+17:35 <@matches> There are implicit barriers at the end of each parallel section
+17:35 <@matches> Oh, also make sure the scope is correct
+17:35 <@matches> Put {} around things
+17:35 < Pommers> Okay
+17:35 < Pommers> Imma come back to it in a moment
+17:35 < Pommers> Forgot to go pick up my housemate :/
+17:36 < Pommers> ty matches
+17:36 <@matches> (You don't need the {} if you have a loop immediately after the parallel directive though)
+17:37 <@matches> Using OMP with certain text editors is a nightmare because they want to automatically put preprocessor directives in the first column
+17:37 <@matches> Which totally screws up indentation
+17:37 <@matches> Certain uses of OMP don't actually use indentation in the first place though, which I can't understand at all
+17:37 <@matches> They indent the for loop but not the parallel directive that applies to it
+17:38 * matches shudders
+17:38 <@matches> These are the same lecturers that discouraged us from using functions because function calls slow the program down
+17:38 <@matches> Whole program should be in main()
+17:38 <@matches> Goto if necessary
+17:42 <@matches> (I compiled something with and without a function call and saw that it was the exact same assembly and then proceeded to totally ignore any programming advice they gave us from then on)
+17:43 <@matches> I guess it would be true if you had an ancient compiler
+17:46 < sulix> (Secret: function calls _are_ slow. So is goto, though, so the point is moot.)
+18:07 <@matches> Baha
+18:08 <@matches> There is some kind of deep maths behind why transforming things relative to Path bounds works
+18:08 <@matches> I guess
+18:08 <@matches> It is both obvious and not obvious
+18:08 <@matches> It is very frustrating
+18:09 <@matches> I think this project is somewhat more appropriate for a maths major than mechatronics engineers...
+18:09 <@matches> I guess I don't have to go into the maths, but if I don't then I'm basically just saying "I tried this because it seemed like it would work, and it did!"
+18:10 <@matches> Even the Logarithm I implemented has nice maths in it
+18:11 <@matches> Which is just slightly beyond my ability to explain satisfactorily
+18:14 < sulix> I don't think maths-majoring has helped me much. It gives me snarky things to say about floats vs rationals, but doesn't stop the fact that I've now spent over a week trying to work out where the -ve signs need to go in the quadtree.
+18:16 <@matches> :(
+18:18 < sulix> On the bright side, by the power of trial, error, cribbing from the xkcd comic, and forcibly recreating all of the GPU buffers 4 times a frame, panning around the quadtree now seems to work.
+18:18 <@matches> Yay!
+18:18 <@matches> Can you zoom yet
+18:19 < sulix> Almost*
+18:19 <@matches> Zooming is just panning but with different numbers
+18:19 <@matches> Or is panning just zooming but with different numbers
+18:19 <@matches> Something
+18:19 <@matches> Some of the numbers are zero
+18:19 <@matches> Or possibly 1
+18:20 <@matches> Let me know when eye_of_the_rabbit works and we will have a performance show down!
+18:20 < sulix> Zooming in works about as well as it did before. Zooming out works as long as you don't try to zoom out beyond the original view.
+18:20 < sulix> Panning around the document works, though might have some problems if you try to pan outside (0,0)-(1,1) from the original view.
+18:20 <@matches> Who needs to zoom out anyway
+18:22 <@matches> I'm going to make the debug font more dramatic to answer some criticism
+18:22 <@matches> Apparently I need to indicate the width of the view in SI units
+18:22 <@matches> (And in really big text)
+18:25 < sulix> But there are no units for the view!
+18:25 <@matches> On my monitor the view is 22mm
+18:25 <@matches> window rather
+18:25 <@matches> So just multiply the view width by that
+18:25 < sulix> Just short of an attoparsec...
+18:33 < sulix> Okay, fixed the "you have to zoom in on non-binary-fraction boundaries for infinite precision issue that's plagued the quadtree for months.
+18:33 < sulix> Now we can see: discontinuities at quadtree node boundaries!
+18:33 < sulix> Fortunately, I have an excuse for leaving them there!
+18:34 < sulix> "The object wasn't added at that resolution."
+18:34 <@matches> Heh
+18:34 < sulix> (Also: we totally don't solve cubics analytically, so they're worse than they need to be)
+18:35 * sulix smells a "further work" section.
+18:35 <@matches> You have a "current work" section? Jealous
+18:36 * sulix didn't say that.
+18:36 <@matches> Apparently as long as I make something pretty people will be impressed
+18:36 <@matches> I wonder if it's too late to implement shading (again)...
+18:36 < sulix> Maybe different-coloured outlines?
+18:36 <@matches> Haha
+18:36 < sulix> More demo svgs?
+18:36 <@matches> I quite like the turtles demo
+18:37 <@matches> Unfortunately for reasons mentioned earlier it can't actually add turtles forever
+18:37 <@matches> Well it could
+18:37 <@matches> But you couldn't stop it and go look at them
+18:37 <@matches> You'll only ever see the bottom one
+18:37 <@matches> The demo that draws 20 and then zooms back out and then in again is probably good enough
+18:38 < sulix> Hmm... eye_of_the_rabbit is segfaulting the quadtree.
+18:38 <@matches> It clears the document every so often
+18:38 <@matches> Try commenting that out first?
+18:38 < sulix> That'd probably do it.
+18:38 <@matches> I thought we probably wanted to test zooming without altering the number of primitives, and that was the only way I could think of doing it
+18:38 < sulix> It also made the quadtree slow down, though that's a side effect of something I like to call "shitty coding".
+18:39 < sulix> The quadtree is full of it.
+18:45 * sulix is merging now. I love the #pragma message that happens for every file!
+18:48 < sulix> Code is up for your enjoyment/horror.
+18:48 * sulix breaks for dinner.
+21:01 <@matches> Yeah the #pragma message probably wasn't that good an idea
+21:02 <@matches> The problem was there are 3 different "Reals" now :S
+21:02 <@matches> So I wanted to make sure I knew which ones it was using
+21:08 < sulix> Fair enough.
+21:11 < sulix> Oh dear god, what have you done to the debug text?
+21:13 * sulix shudders.
+21:14 <@matches> It's readable!
+21:14 <@matches> Through the automerge seems to have forgotten the #ifdef 0
+21:15 <@matches> Oh that stuff is printed somewhere else...
+21:16 <@matches> Anyway, adding stuff seems to work!
+21:16 <@matches> But not from the script for some reason
+21:16 <@matches> Oh right, the clearing
+21:17 < sulix> It shouldn't work totally in the quadtree, I've just made it break more quickly.
+21:17 < sulix> Basically, you can (a) only add to the root node and (b) nodes are not yet updated with new objects if they already exist.
+21:17 <@matches> It doesn't work when things overlap nodes?
+21:17 <@matches> Right
+21:17 <@matches> I was getting excited for a minute
+21:18 < sulix> On the bright side, it no longer creates an entirely new quadtree for every individual object and it actually adds new things to new child nodes.
+21:20 <@matches> Running eye of the rabbit I see a LOT of "Recreate buffers" messages but no actual rabbits
+21:21 < sulix> It now recreates the buffers every frame because that was easier than getting it to recreate the buffer in arcane parts of quadtree code.
+21:29 <@matches> Well, it does work when you add something to the root node I guess
+21:30 < sulix> Almost.
+21:31 < sulix> If you zoom in, zoom out, add something to the root node and then zoom in again it isn't there.
+21:31 < sulix> But that will (fingers crossed) soon be resolved through the power of recursive functions.
+21:31 <@matches> Hmm, that's almost what happens when you use IEEE singles!
+21:34 < sulix> I'm still trying to work out how I can delay the generation of new child overlays until after all new objects have been added.
+21:34 < sulix> If I do things the obvious way, it'll generate thousands of overlays and totally kill performance.
+21:35 <@matches> Damn
+21:35 <@matches> I think I just need to write lots of stuff and fast
+21:35 <@matches> Well
+21:35 <@matches> Some form of result would be nice
+21:35 <@matches> A graph
+21:41 < sulix> I think I've managed to make the quadtree even slower than ParanoidNumber<GmpRat> would be.
+21:42 <@matches> How though? It seemed like it would be efficient
+21:43 <@matches> It doesn't have to render the whole document
+21:43 <@matches> s/render/transform
+21:44 < sulix> Well, it has to regenerate the entire quadtree everytime there is a new bezier, and there are lots of O(n) linked lists and recursive functions there.
+21:44 < sulix> And doing this the naïve way generates a pathalogically-worst case situation.
+21:45 < sulix> (I'm still waiting for my first "add something test" to complete.
+21:45 < sulix> )
+21:45 <@matches> Hmm
+21:46 <@matches> I guess once you already have a document with lots of detail in it, a quadtree is good
+21:46 <@matches> But actualy making the document with lots of detail in it...
+21:46 * sulix suspects it might just be infinite looping.
+21:46 <@matches> Why does it have to rebuild the entire quadtree? Can't it just modify the current node + nearest neighbours?
+21:47 <@matches> Or go up to the parent and add all the objects in the parent, then split them up for the children
+21:47 <@matches> Hmm
+21:48 <@matches> You need to be able to add objects to the ancestors as you zoom out I guess
+21:48 <@matches> But you should be able to do it lazily?
+21:48 <@matches> In theory
+21:48 < sulix> In theory.
+21:48 * matches is glad he is not writing the quadtree after all
+21:48 < sulix> The big problem is that adding things to the quadtree needs to be done in bulk to be efficient.
+21:49 < sulix> i.e. If you add a whole bunch of things to one node, and then a whole bunch of things to another, it's okay.
+21:49 < sulix> But if you alternate (add something to one), (add something to the other) repeatedly, you fragment the quadtree and it treats each bézier as it's own overlay from then on.
+21:49 < sulix> The easy way to do things is the latter way.
+21:50 < sulix> Because it's hard to get all of the info you need about what things have changed in bulk at the end of an entire operation.
+21:51 < sulix> But clearly doing things curve by curve is not going to cut it if even the simplest examples take over 5min/frame to render.
+21:52 <@matches> Well if it's any condolance, ParanoidNumbers are still worse than that
+21:53 * sulix should say "5min and counting"/frame.
+21:53 < sulix> I've not yet had a frame render.
+21:53 <@matches> Hey, at least you can still type into a terminal
+21:54 <@matches> When I run ParanoidNumbers I can't even kill the process for 5 minutes...
+21:54 < sulix> I am thankful for these small mercies.
+21:55 <@matches> I'd hoped they'd be a bit better with the more efficient transformation model but apparently not enough
+21:55 <@matches> In fact they are segfaulting again
+21:56 <@matches> I thought I stopped that
+21:56 <@matches> The plot thickens!
+21:57 <@matches> They segfault when std=c++0x
+21:57 <@matches> But not when std=c++11
+21:57 < sulix> Oh dear god.
+21:57 <@matches> I suspect it is related to the use of "auto"
+21:57 <@matches> And it is probably why google told you not to use it
+22:00 <@matches> Actually it's more likely because I forgot to make clean
+22:01 <@matches> Well I guess I will come back to them once I actually have something resembling a thesis draft
+22:01 <@matches> Hahaha
+22:02 <@matches> The turtles script is way cooler than the rabbit one by the way, if you haven't run it yet
+22:02 <@matches> (But it breaks the quad tree even more)
+22:04 <@matches> And PN do work if you restrict the size to like, 3
+22:05 <@matches> News in 5 minutes: Is it actually better than just using doubles
+22:06 <@matches> It seems to speed up every so often and then slow down again
+22:06 <@matches> Aaamd
+22:06 <@matches> Yeah that turtle rounded to the wrong spot
+22:07 <@matches> I should see how well our custom Rational implementation does too
+22:12 <@matches> I am confused by PN
+22:12 <@matches> A size limit of >= 5 causes apocalyptic memory usage
+22:12 <@matches> A size limit of 4 is totally fine and actually not much slower than Gmprat
+22:13 <@matches> Also I have a sudden urge to compile this with MinGW so that the Engineers who mark it can actually run it
+22:13 <@matches> I mean, they probably won't run it
+22:13 <@matches> But the last thing I want is for them to try and not be able to
+22:13 <@matches> And then just assume I fudged the results
+22:14 <@matches> I mean, a rabbit scaled to 1e-6 and then viewed under 1e6 magnification looks the same as the original rabbit...
+22:14 <@matches> It's not really even worth including both images
+23:56 <@matches> One does not simply cross compile for MinGW
+23:57 <@matches> Although I must say I was bracing for it to be worse
+23:58 * matches stares in shocked amazement at NO ERROR MESSAGES
+23:58 <@matches> COULD IT BE
+23:58 <@matches> COULD I HAVE SUCCEEDED?
+23:59 < Pommers> Nope.
+23:59 <@matches> -_-
+23:59 <@matches> If we didn't need spectators I'd totally /kick you
+23:59 < Pommers> 99 commits in my assignments repo >.>
+23:59 <@matches> Pfft
+23:59 <@matches> Commit them all to IPDF
+--- Day changed Sun Oct 05 2014
+00:00 < Pommers> I can kill your percentage of lines here. That's what you asked me to do
+00:00 < Pommers> Also
+00:00 < Pommers> First
+00:00 <@matches> err:module:import_dll Library SDL2.dll (which is needed by L"Z:\\home\\sam\\Documents\\University\\2014\\ipdf\\code\\src\\ipdf") not found
+00:00 <@matches> Hmm
+00:03 <@matches> If I try link with static SDL2 everything goes to hell though :(
+00:04 <@matches> I guess I can just add SDL2.dll
+00:05 <@matches> It runs in Wine
+00:05 <@matches> Does that make it more or less likely to run under windows
+00:05 <@matches> Ah crap the Qt stuff isn't compiled in though
+00:05 <@matches> Qt is annoying
+00:05 <@matches> They appear to ask you for money if you try download their source
+00:06 <@matches> Also they don't like you using Qt4 and I really can't remember why I picked Qt4 instead of Qt5 now
+00:07 <@matches> I guess I assumed it would be better, after experiences with GNOME 2 -> GNOME 3
+00:07 <@matches> New = terrible
+00:08 <@matches> Oh dur this is what apt-get source is for
+00:10 <@matches> I will just feel a lot safer if I know that the marker can actually run the software without needing to know linux
+00:10 <@matches> Call me a Paranoid Number...
+00:10 <@matches> (Ho ho ho)
+00:11 <@matches> (This is probably a sign that it is bed time)
+00:13 < Pommers> Yeah, you should probably go to bed matches
+00:17 <@matches> What about you?
+00:18 < Pommers> I'm already in bed
+00:18 <@matches> SULIX
+00:18 <@matches> THERE IS A GOTO
+00:18 * Pommers grabs out his pitchfork
+00:20 <@matches> I only saw it because it is also outside an #ifdef and raises an "unused label" warning
+00:20 <@matches> How many others are there...
+00:24 <@matches> There is also a goto in stb_truetype.h but I'll let that one slide since sulix didn't write it
git.ucc.asn.au / ipdf / documents.git / blobdiff
UCC git Repository :: git.ucc.asn.au