00:00:51 <oklopol> well, now it at least works on the empty screen.
00:00:55 <oklopol> now let's try a glider....
00:01:19 <oklopol> well there's a glider, but it takes ages to reach it, not the fastest impl there it :)
00:01:36 <oklopol> it's quite visually pleasing imo
00:01:53 <ehird> oklopol: use http://www.formauri.es/personal/pgimeno/temp/esoteric/paintfuck/paintfuck.php it has fat animation
00:01:56 <ehird> and origin top left
00:02:23 <ehird> oklopol: failing that ill try it in the java interp
00:05:40 <oklopol> flumrgh, it didn't wurk :)
00:12:12 <pgimeno> HUGE performance improvement: http://www.formauri.es/personal/pgimeno/temp/esoteric/paintfuck/paintfuck-canvas.php
00:13:55 <ehird> that is INSANELY FAST
00:14:01 <ehird> pgimeno: you are a god
00:14:29 <ehird> pgimeno: my god, blink and its finished execution
00:14:29 <pgimeno> well, the merit is yours and Asztal's :)
00:14:50 <pgimeno> it does 200 steps per animation frame
00:15:06 <ehird> the problem with that is that you miss out on the juicy bits
00:15:10 <ehird> maybe make that configuratble?
00:15:13 <ehird> should just be a few lines
00:15:23 <pgimeno> I was thinking of that, but wanted to show you :)
00:16:04 <pgimeno> Langton's ant now takes just a few seconds to escape at 128x128
00:16:49 <ehird> pgimeno: also, you should default to black = background
00:16:52 <ehird> like everyone else
00:17:52 <ehird> try your gol on this!!
00:18:38 <ehird> oklopol: set dimensions = 1000,1000, origin=topleft, animation step=0, put it in and animate
00:18:54 <pgimeno> ehird: the web is white! :P
00:19:08 <ehird> pgimeno: so is the flash interp, but the GRID is black background
00:19:12 <ehird> and everyone says white/black
00:19:15 <ehird> so it's just confusing
00:19:35 <oklopol> but i can't test a glider in the exe
00:20:02 <ehird> pgimeno: haha, try whee!
00:20:10 <ehird> (http://forums.tigsource.com/index.php?topic=3710.msg110154#msg110154)
00:21:19 <ehird> pgimeno: the main problem with your 200-per is that t he display is jerky
00:21:27 <ehird> you can't see the head if it's a bouncing-ball type thing
00:21:33 <ehird> so i think that configurable that would be good
00:24:33 <ehird> pgimeno: heh, your interp is quite unusable now: you can't see programs running
00:24:35 <ehird> since it's so fast
00:24:41 <ehird> needs some of that configuring ;)
00:24:44 <jayCampbell> JJusutst a anonotthheerr brbraiainnffuucckk hahcackkeerr
00:27:33 <oklopol> i have no idea because it shows two generations :)
00:27:45 <oklopol> i made a glider, and it's not dying, not sure if it's working though.
00:27:52 <ehird> pgimeno: does it totally redraw each time?
00:27:57 <ehird> if so that's silly just redraw what needs redrawing
00:28:01 <ehird> oklopol: using pgimeno's?
00:28:34 <pgimeno> ehird: well, that's on the browser, it draws on every pixel change
00:28:43 <ehird> oklopol: set ms = 0, iterations = 500
00:28:48 <ehird> should go really fast
00:29:42 <pgimeno> oklopol: this one: http://www.formauri.es/personal/pgimeno/temp/esoteric/paintfuck/paintfuck-canvas.php
00:29:57 <ehird> *[[en*w]*s[nw*s]*e[ws*e]*n[se*n]*w] <- someone on the forums posted this. BOXWORLD!
00:32:42 <oklopol> hmm... it might be working, but it's definitely not pretty.
00:32:54 <ehird> pastie.org the code
00:32:55 <oklopol> should've done it like oerjan suggested
00:33:29 <oklopol> i can http://www.vjn.fi/pb/p244563523.txt the code, don't know about pastieing
00:34:15 <oklopol> the problem is showing two iterations at once, it simply doesn't look good.
00:34:24 <oklopol> and makes it quite hard to tell whether that's even working.
00:34:37 <ehird> oklopol: also it's dog slow
00:35:42 <ehird> reaaaaaaaaaally slow
00:35:47 <ehird> you should make it migrate an entire region at a time
00:36:24 <ehird> a glider goes straight to the next glider step
00:36:28 <ehird> then it goes on to the rest of the grid
00:39:21 <oklopol> i have no idea what you mean, unless you mean what you said, which you cannot have meant
00:39:34 <ehird> if there's a glider there
00:39:37 <ehird> make the glider go on to the next glider iteration
00:39:40 <oklopol> anyway if you change the first four lines to
00:39:41 <ehird> then calculate all the rest of the grid
00:39:59 <oklopol> you can clearly see it do one correct iteration
00:40:04 <oklopol> then fail on the next iteration
00:40:29 <oklopol> yeah that canvas thing is much too slow for this
00:40:50 <ehird> oklopol: hard to get much faster
00:40:53 <ehird> thats the fastest interp so far
00:40:58 <ehird> put up the iterations per animation
00:41:27 <oklopol> does that do some kind of optimization?
00:43:44 <ehird> oklopol: it makes it do 2000 iterations per animation
00:43:48 <ehird> and not wait per animation
00:44:31 <pgimeno> oklopol: wow, even if it does not seem to be working properly I'm impressed (and no, the interpreter doesn't optimize, except it has a jumps table)
00:45:27 <oklopol> i'm pretty sure it works now, had just a minor bug
00:45:54 <oklopol> (forgot i need to forget the old values at some point, and an error naturally occurs due to this only on the second iteration)
00:46:03 <Sgeo> Is it safe to say that the sort of person in this channel is the sort who has no need to cheat on exams/
00:46:30 <pgimeno> I had to cheat on history exams :P
00:46:45 <Sgeo> On my economics exam, the professor left the room for a few minutes, and I hear everyone asking things like "For 5, what did you get?", things like that
00:47:55 <oklopol> i was recently the only one to score a 5/5 in one exam, i think it'd be a bit counterproductive to ask people what they answer :P
00:48:08 <Sgeo> oklopol, lol, same here
00:48:25 <Sgeo> There were two questions I was clueless about
00:48:31 <Sgeo> But I would NEVER consider cheating
00:48:43 <oklopol> we usually have 4 questions, if you don't know the answer to 2, you fail.
00:48:56 <Sgeo> 50 question exam
00:49:39 <oklopol> i have nothing against cheating.
00:49:42 <pgimeno> oklopol: can I see the fixed version?
00:49:54 <oklopol> pgimeno: yes, not that i'm sure it still works ;)
00:50:34 <oklopol> http://www.vjn.fi/pb/p533314231.txt
00:50:59 <oklopol> goes vertical - horizontal - vertical ...
00:51:36 <oklopol> (the last cycle's value is in the bottom-left of a 2x2 square, current is in top-right.)
00:51:53 <oklopol> would probably be clearer if they were like next to each other or if the squares were bigger or something
00:52:08 <oklopol> but, it'd take me quite a while to do even a trivial change, because that's all manually done.
00:52:15 <oklopol> (thought it'd be a lot shorter)
00:52:54 <oklopol> if you want to know what the flicker is all about, the top-left thingie is the current cell being modified
00:53:07 <oklopol> the one on bottom-right is where the counrer ends
00:53:23 <oklopol> the four flickering lights are the negations of the counter's cells
00:53:36 <oklopol> (makes the logic to check what happens to current cell clearer)
00:55:01 <oklopol> that gets very confusing, i didn't check whether it works :D
00:55:10 <oklopol> but i can try, after this other test i'm doing now
00:56:48 -!- adimit has left (?).
00:59:42 <pgimeno> if you cleared the cells done it would be great too
01:00:20 <oklopol> i could do that, i just need the last row
01:00:31 <oklopol> lol i never even thought of that:D
01:01:05 <oklopol> let's see... this should be trivial
01:02:41 <oklopol> and you fix everything in a second
01:03:41 <oklopol> http://www.vjn.fi/pb/p422562455.txt <<< because of the change, there's now a piece of code there that doesn't do anything.
01:03:46 <oklopol> just in case someone wants a challenge
01:04:03 <oklopol> damn, it's trivial to find it, i've commented that code.
01:04:59 <jayCampbell> > Weave and brainfork conventions can be used together. That is, multiple initial threads can be started using semicolons, and embedded Y's can cause further forking.
01:05:05 <oklopol> wonder what happens when it hits the border...
01:05:22 <jayCampbell> http://esolangs.org/wiki/User:JayCampbell/weave.rb
01:05:30 <pgimeno> for the record, the second version of langton's ant took me about 3 hours
01:06:39 <oklopol> hmm. wonder how long it took me to do 110
01:07:25 <oklopol> btw that crashes completely when the glider hits the border :P
01:07:37 <oklopol> what's langton's and again
01:07:49 <oklopol> the ant is somewhere, and it turns right or left depending on current cell
01:07:55 <oklopol> and flips it if something.
01:08:47 <pgimeno> there's a current direction, turn left and if 0, turn right if 1, flip and advance
01:10:15 <oklopol> now i almost feel like making that in pf... :D
01:10:19 <pgimeno> the second version fills the whole 2x2 square
01:10:23 <oklopol> how long was yours again? ;)
01:10:31 <pgimeno> which is what makes it notable
01:11:14 <pgimeno> try and see: http://www.formauri.es/personal/pgimeno/temp/esoteric/paintfuck/paintfuck-langton-nonhollow.pfk
01:11:32 <pgimeno> try and see: http://www.formauri.es/personal/pgimeno/temp/esoteric/paintfuck/paintfuck-langton-nothollow.pfk
01:12:24 <oklopol> stores the direction, it's not completely black, right
01:12:41 <oklopol> yeah i think you need that.
01:12:51 <oklopol> i'll step-by-step, don't answer!
01:13:20 <oklopol> now i closed the interp :D
01:14:09 <oklopol> so yeah okay, that's pretty good, although i'm pretty sure you could get that compressed quite a lot
01:14:25 <pgimeno> maybe, I didn't figure how
01:14:42 * pgimeno is seeing the r demon in life
01:15:08 <oklopol> can you tell me what that code does? i don't feel like reading
01:15:24 <oklopol> like, the gist of how you do it
01:16:11 <pgimeno> http://www.formauri.es/personal/pgimeno/temp/esoteric/paintfuck/paintfuck-langton-nothollow-commented.pfk
01:17:06 <pgimeno> wherever it says "we came from x" it should say "our last move was x"
01:18:11 <oklopol> i have to go sleep now, i'll read that tomorrow
01:55:01 <jayCampbell> warrie has there ever been an Easy interpreter?
01:59:35 <pgimeno> http://p-nand-q.com/humor/programming_languages/gplz/gplz_easy.html
04:02:52 -!- Corun has quit ("This computer has gone to sleep").
04:58:44 -!- Slereah has quit (Read error: 145 (Connection timed out)).
05:13:22 <jayCampbell> You are standing inside your ramshackle wooden hut.
05:13:55 <jayCampbell> i'm going to ask jon ripley to make it multiplayer
05:29:34 <decipher> ehird: i checked your copier, it's sweet :)
05:30:07 -!- Sgeo has quit (Read error: 104 (Connection reset by peer)).
06:06:13 <jayCampbell> 999999 bbbooottttttllleeesss ooofff bbbeeeeeerrr ooonnn ttthhheee wwwaaallllll,,,
06:06:13 <jayCampbell> 999999 bbbooottttttllleeesss ooofff bbbeeeeeerrr,,,
06:22:34 -!- bsmntbombdood_ has joined.
06:27:39 -!- bsmntbombdood has quit (Read error: 60 (Operation timed out)).
06:31:56 -!- Slereah_ has joined.
06:47:34 -!- bsmntbombdood_ has changed nick to bsmntbombdood.
07:38:38 -!- oerjan has joined.
07:39:10 -!- oerjan has set topic: http://tunes.org/~nef/logs/esoteric | Y RLY.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:07:07 <jayCampbell> it will soon be .. an irc bot with persistent threaded cross-communicating subroutine-calling brainfucks
08:07:18 <jayCampbell> because, you know, that's exactly what the world needs
08:12:29 <oerjan> the world is _so_ fucked
08:20:05 -!- oerjan has quit ("leaving").
08:47:38 -!- Slereah_ has quit (Read error: 60 (Operation timed out)).
09:02:19 -!- GreaseMonkey has quit ("I'm a thaasophobic.").
11:27:09 <MizardX> Heh. I tried to calculate the number of ways I could generate all the permutations of a given cycle by just shifting subsequences one step at the time. For zero-, one- and two-length cycles I got the answer 1. For a three-length cycle I got 40 within a second. But trying to calculate it for a four-length cycle, it almost froze up the whole computer :S
11:27:10 <MizardX> My guess is that the number is around 2*n!!/(n!^2) :)
11:38:28 -!- Slereah_ has joined.
12:18:14 -!- Sgeo has joined.
12:32:09 -!- Corun has joined.
12:38:24 <ehird> but it only handles one-rows
12:50:12 <decipher> but i am sure you can generalize
12:50:32 <decipher> also, on my obfuscated interpreter the copying was quite fast
13:12:53 <ehird> decipher: well, it's hard to generalize to arbitrary depth because if you just sweep through it, you eat up the walls
13:28:22 <ehird> decipher: if you have any ideas, though?
13:42:12 -!- Corun has quit ("This computer has gone to sleep").
13:42:48 <ehird> oklopol: paintfuck
13:42:55 <ehird> it copies a line leftwards constantly
13:43:04 <ehird> i.e. you can put any one line and it scrolls it
13:43:09 <ehird> i want to generalize it to any depth
13:43:21 <oklopol> mm'kay, isn't that like 10 characters of code?
13:43:33 <ehird> you have to detect the ceiling/floor
13:43:39 <ehird> otherwise you eat the walls up
13:43:43 <ehird> and never go on to the next column
13:43:54 <ehird> the one-line copier is trivial ofc
13:45:40 <decipher> ehird: your routine was more like a move than copy :)
13:46:07 <decipher> although i am not sure if it might be possible to dynamically calculate the offset and move the head accordingly at all
13:46:18 <decipher> as in, i am not sure if a true copy algorithm can be possible
13:46:27 <ehird> decipher: oh, true
13:46:34 <ehird> well it was a scroll
13:46:43 <ehird> i dont' think you can do a generic scroll
13:46:48 <ehird> its impossible to tell walls from blocks
13:46:54 <ehird> you make the wall a special pattern
13:47:00 <ehird> that your program detects
13:47:07 <ehird> then you can't copy that pattern, but if it's weird enough it won't happen
13:47:12 <decipher> true, but that's not "general" then :)
13:47:19 <ehird> as general as matters :P
13:59:44 <pgimeno> my binary counter (may assume infinite grid): sse*ww*[e*[*nn[*s*e*wn]se[*wn*se]s*]*w*[*s[*]nw*]*en[*e]*s[*e*w]*[*e*]s*n*[*w*]s[*]*]
13:59:45 -!- Slereah_ has quit (Read error: 113 (No route to host)).
14:00:05 <ehird> pgimeno: niiiiiiiice
14:00:13 <ehird> someone make a decimal conuter
14:00:19 -!- lostgeek has joined.
14:00:20 <ehird> that OCRs the digits it outputs to add :)
14:11:34 <ehird> lostgeek: context for what i was saying -
14:11:45 <ehird> a decimal counter would be cool, i.e. it draws the digits and OCRs them to increment :)
14:18:25 <ehird> AnMaster said something?
14:18:27 <ehird> (He's on /ignore.)
14:18:36 <AnMaster> lostgeek, hm I can't remember seeing you here before?
14:19:04 <lostgeek> AnMaster: I joined yesterday ;)
14:19:24 <ehird> (Context for a person who I cannot see: He's a paintfuck person.)
14:22:10 <lostgeek> ehird: would be cool, but I think a bit hard to realize
14:22:21 <ehird> lostgeek: i don't think -that- hard
14:22:45 <ehird> i mean, write code to output a certain digit for 0-9, then one to look at its pixels (just make them monospaced) to detect it into the head
14:22:49 <ehird> then just do regular adding stuff
14:22:53 <ehird> not easy, but not really hard
14:26:51 <pgimeno> last, shorter, faster version of binary cnt: sse*ww*[e*[*nn[*s*e*wn]se[*wn*se]s*]s[*]*nw*[*s[*]nw*]*en[*e]*ss[*e*w]n*[*w*]s*]
14:35:49 <ehird> pgimeno: that's not shorter...
14:39:17 <ehird> i know oklopol would say that.
14:39:25 <ehird> we could just replace him with a bot and never notice.
14:39:29 -!- Sgeo has quit (Remote closed the connection).
14:39:30 <ehird> apart from the coding skills part.
14:41:20 <oklopol> to inc a binary counter, when you're on a constant 1-bit to the right of it, w[*]*w*[*e*]*, you go left, then null all ones, make the zero into a one, then go right, skip all the zeroes to land on the constant bit to the right of the counter
14:41:30 <oklopol> to do this constantly, add a while to that
14:41:37 <oklopol> what are you guys doing then?
14:46:44 <ais523> AnMaster: I say the appropriate response, but such that ehird doesn't have a clue what I mean due to lack of context
14:47:12 <ehird> I do actions by saying them to IRC.
14:48:26 <oklopol> [w[*w]*e*[*e*]*] <<< binary coutner
14:49:07 <oklopol> also the police calls, i couln't really tell them what the pizza attackers looked like, so they're gonna go photograph the whole staff and show me the pics :D
14:49:16 <ais523> oklopol: pizza attackers?
14:49:40 <oklopol> about a week ago, i ordered pizza, and got beat up by the delivery guys
14:49:53 <ais523> what sort of delivery guy does that?
14:50:12 <ehird> maybe you called up the Punch 'n Pizza place instead
14:50:25 <oklopol> ais523: i would tell you what i think the answer is, but that would be racist.
14:50:26 <ehird> [w[*w]*e*[*e*]*] <-- oklopol how can this work it will never run
14:50:38 <oklopol> ehird: you have to be on a constant 1 bit
14:50:42 <ehird> oklopol: they were blobs of mauve goo?
14:51:17 <ehird> scum the lot of them
14:51:38 <ehird> oklopol: your binary counter is pretty awesome
14:51:46 <ehird> w*[w[*w]*e*[*e*]*]
14:51:50 <oklopol> were you doing that same thing?
14:51:50 <ehird> the full experience
14:52:08 <ais523> hmm... it seems the Door was broken again last Sunday, good thing I didn't try it
14:52:28 <oklopol> that long code there, about a binary cunt, was it that same thing
14:52:45 <ehird> it kept the previous results
14:52:49 <ehird> didn't look like yours
14:52:54 <ehird> oklopol: you should make yours actually output in binary
14:52:57 <ehird> instead of a soldi line
14:53:54 <oklopol> maybe i could run yours..........
14:55:06 <oklopol> ehird: i mean the set {ehird, pgimeno}
14:56:02 <oklopol> anyway i don't think i'll actually do it, why the fuck would i
14:57:24 <ehird> *w*[[*w*]*e*e*[*e*]*w*]
14:57:30 <ehird> i just made your counter simpler
14:57:50 <ehird> yes but it runs simpler
14:57:54 <ehird> it doesn't use binary
14:57:55 <oklopol> and it's not a binary counter
14:58:03 <ehird> oklopol: a binary counter would OUTPUT IN BINARY
14:58:22 <ehird> oklopol: so make it output in binary! :P
14:58:27 <oklopol> ehird: it outputs in binary, just doesn't store the values
14:58:29 <ehird> 0 = space, 1 = dot naturally
14:58:55 <oklopol> that's a binary counter, pgimeno's is one that outputs binary numbers
14:59:10 <oklopol> which isn't really useful, unlike a counter
14:59:28 <ehird> ais523: we're talking about paintfuck
14:59:40 <ehird> which is the first interesting bf dialect in ages
14:59:40 <ehird> http://forums.tigsource.com/index.php?topic=3710.0
14:59:47 <ehird> the thing is, the memory is actually the screen
14:59:54 <ehird> so your program has to think in its output drawing format
15:00:03 <ehird> langton's ant, game of life, rule 110, etc have been done
15:00:20 <oklopol> i'm not saying paintfuck isn't interesting, i'm just saying it's not a new idea
15:00:31 <ehird> oklopol: yeah ok w/e :P
15:00:35 <ehird> but ais523 hasn't seen it
15:00:42 <ehird> ais523: http://www.formauri.es/personal/pgimeno/temp/esoteric/paintfuck/paintfuck-canvas.php javascript interp, it's fast
15:00:50 <oklopol> but what is new is someone having linked an implementation so i can play with it :P
15:01:27 * ehird makes his counter go forever
15:04:31 <ehird> *w*[[[*w*]*e*e*[*e*]*w*]*s*e*w]
15:05:03 <ehird> aka slowest screen fillder ever
15:05:56 <oklopol> not really, that's O(n^2) filling tiem
15:06:38 <ehird> oklopol: after it fills the screen it then mangles the topleft and topright pixels
15:06:40 <oklopol> point is doing it in binary is O(2^n)
15:06:43 <ehird> so it's the slowest screen filler ever
15:06:48 <ehird> as it takes more than infinite time to fill the screen
15:07:00 <ehird> oklopol: it makes the topleft and topright pixels blac
15:07:07 <oklopol> infinity = -1, as we all know
15:07:15 <oklopol> so it's as fast as you can get
15:10:25 <oklopol> err..... what the fuck, still here......
15:39:02 <pgimeno> http://www.formauri.es/personal/pgimeno/temp/esoteric/paintfuck/langtonsant.php - Langton's ant (unrelated to PFK)
15:39:43 <ehird> gee how many times have we said "AnMaster: PaintFuck" today
15:39:53 <lostgeek> well this time it was my fault
15:40:12 <lostgeek> i thought i was in the other terminal window and pressed up and enter
16:20:45 -!- puzzlet_ has quit (Remote closed the connection).
16:20:53 -!- puzzlet has joined.
16:20:54 -!- KingOfKarlsruhe has joined.
16:26:20 <lostgeek> mh. I got a problem with my code window...
16:26:46 <lostgeek> lets say I have a loop like *[w*] or something
16:26:51 <ais523> AnMaster: busy with things including RL
16:27:03 <ais523> and some non-RL but non-eso programming
16:27:05 <lostgeek> and my pointer is on the second *
16:27:17 <ais523> and trying to recover an email that Outlook Web Access deleted yesterday
16:27:23 <ais523> I spent over an hour writing it
16:27:24 <lostgeek> now I call nextStep() and move to ']'
16:27:31 <ais523> then accidentally hit back on my mouse, and couldn't get back to it
16:28:04 <lostgeek> how I was solving it was to jump back to the left of '['
16:28:49 <lostgeek> but in that case my pointer is on the first * which is confusing, since I don't execute it
16:30:06 <AnMaster> lostgeek, you move before you execute or execute before you move?
16:30:34 <lostgeek> which solves other problems I would have when executing before moving
16:30:52 <AnMaster> lostgeek, now I don't 1) know how similar it is to plain bf, 2) what language you are writing it in
16:31:02 <ehird> http://www.iq0.com/notes/deep.nesting.html
16:31:11 <ehird> (AnMaster will hate that article)
16:31:11 <AnMaster> I would just connect the ] node's next pointer to the matching [
16:31:27 <AnMaster> the up pointer to the instruction after
16:31:51 <AnMaster> and the ['s down pointer to the first instruction in the loop
16:32:27 <AnMaster> lostgeek, and move before execute is sane
16:32:43 <lostgeek> I'm working with strings (on java)
16:32:55 <ehird> the code before execution
16:33:21 <AnMaster> but I would represent the source of plain bf as a 2D linked list
16:33:37 <AnMaster> actually to save some space I wouldn't have separate up and down pointers in the structs
16:33:43 <AnMaster> I would have a single "aux" pointer
16:33:54 <AnMaster> since I wouldn't need up and down in the same struct
16:34:52 <AnMaster> lostgeek, but this may be totally crazy to do in java
16:35:13 <lostgeek> AnMaster: I think there are LinkedLists in Java. But working with strings was easier
16:35:48 <ehird> public class BFNode { public char type; public BFNode stuff; public BFNode next; }
16:36:18 <ehird> lostgeek: {type='[', stuff={type='w', stuff=null, next=null}, next={type='*', stuff=null, next=null}}
16:36:23 <ehird> lostgeek: then just recurse to loop
16:36:27 <ehird> or keep a manual stack
16:37:29 <lostgeek> yeah. may be a good way to solve it.
16:37:31 <AnMaster> lostgeek, well I did it like this: mmap() source bf file, write a recursive parser to build the tree, pass the tree to the optimizer (replaces ++- with +, reorganize >-<+>-< into >--<+ and such as well as replace ---- with -4)
16:37:40 <ehird> its the only way to solve it sanely
16:37:48 <ehird> of course, insane is good too
16:37:50 <AnMaster> then I used system() to call the compiler
16:37:59 <ais523> AnMaster: do you replace >>>> with >4?
16:37:59 <AnMaster> since it was a compiler, not an interpreter
16:38:05 <ais523> gcc-bf really, really needs that optimisation
16:38:16 <ais523> in fact, I'm considering just getting it to output run-length-encoded BF
16:38:23 <AnMaster> ais523, however it was the one with huge duff's device due to being Def-BF
16:38:25 <ais523> easy enough to postprocess that into normal BF
16:38:39 <AnMaster> I have considered several other optimizing techniques
16:38:54 <AnMaster> such as in a balanced loop try to pre-compute certain parts
16:39:41 <AnMaster> while (*ptr != 0) { *(ptr+1)+=2; *(ptr+2)++; }
16:40:51 <AnMaster> and if number of iterations can be pre-computed...
16:41:05 <AnMaster> so it should try to track possible states
16:41:21 <AnMaster> you can *know* the state after a [-] (turned into a set zero by the optimizer)
16:41:33 <AnMaster> then if you can compute the value it has a bit later
16:41:50 <AnMaster> and if you know that at the start of a balanced loop...
16:41:59 <AnMaster> well you could either turn it into a for loop or unroll it
16:42:08 -!- puzzlet_ has joined.
16:42:11 <AnMaster> at least gcc compile for loops quite a bit faster than while loops
16:42:27 <AnMaster> what do you think of these ideas?
16:42:46 <ais523> AnMaster: I've considered similar things myself
16:43:01 <AnMaster> however I'm unsure if I could manage to implement this
16:43:19 <AnMaster> I mean even writing the basic optimizer was quite painful in C
16:43:27 -!- whtspc has joined.
16:43:33 <AnMaster> some sort of tree rewriting language, hmm
16:43:49 <AnMaster> would need a different variant though
16:43:51 <ehird> whtspc: oklopol wrote a Game of Life
16:43:55 <AnMaster> something that isn't as intercal specific
16:44:00 <AnMaster> and that is possible to actually read
16:44:01 <ais523> although OIL was defined specifically for INTERCAL, it would be possible to do similar langs for other langs
16:44:13 <AnMaster> ais523, do you know of any existing one?
16:44:14 <ais523> at least compared to INTERCAL
16:44:20 <whtspc> I saw something, is there a definite version?
16:44:27 <ais523> AnMaster: no, or possibly I'd have used them rather than writing OIL from scratch
16:44:38 <ehird> whtspc: conway's game of life
16:44:53 <AnMaster> ais523, still oil couldn't easily do variable tracking
16:45:09 <AnMaster> what computational class is oil btw?
16:45:28 <whtspc> i saw the one with the three block, amazing!
16:45:29 <ais523> AnMaster: PDA, I think
16:45:32 <ehird> whtspc: http://www.vjn.fi/pb/p422562455.txt
16:47:08 <AnMaster> ais523, still variable tracing/tracking hm, I don't know how I would even do that
16:47:23 <AnMaster> I mean I could try to trace the entire program but that would be insane
16:47:38 <AnMaster> I would need to give up at unbalanced loops and so on
16:47:59 <ais523> I've been having insane ideas as to how to optimise unbalanced loops, etc
16:48:05 <AnMaster> and what about new simplification possible after the first pass?
16:48:19 <AnMaster> should you try to run it again?
16:48:20 <whtspc> I like to be able to easily save programs in sort of database, do you guys use something special for that?
16:48:39 <AnMaster> I can see how if you just reorganize a bit but leave the pointer the same at the end and the start
16:48:41 <whtspc> should I just open a blog to quickly paste things in
16:49:22 <ehird> if you wanna share it, pastie.org
16:49:27 <AnMaster> but that is about all you can do for them
16:49:36 <ehird> if you want to get a list of them, insertsomerandomwordshereandbookmarkit.pastebin.com
16:49:40 <AnMaster> sure you could try to generate effective code
16:50:01 <AnMaster> such as substract, add 3 to next, add 3 to pointer
16:50:12 <whtspc> yeah thought about pastebin
16:50:19 <AnMaster> ais523, so what is your idea then?
16:50:44 <ais523> AnMaster: work out what's being used for what
16:51:05 <AnMaster> ais523, it would be very hard to track what the state is at the end of the loop compared to the start
16:51:33 <AnMaster> ais523, probably possible and extremely hard for a few cases
16:51:40 <AnMaster> and impossible for the majority
16:51:45 <ais523> so for instance you might deduce that there's a location that's always reached by [>>>] from a particular point
16:53:21 <AnMaster> ais523, hm ok... The worst thing is if you can't figure out, for example say it is based on user input, then figure out where you can resume
16:53:28 <ehird> http://www.formauri.es/personal/pgimeno/temp/esoteric/paintfuck/paintfuck-canvas.php
16:53:31 <ehird> new pgimeno interpr
16:53:45 <AnMaster> if it wasn't for unbalanced loops it would be very very easy to find out
16:53:45 <whtspc> yeah using it right now for life
16:54:00 <whtspc> it's the best for easy use too
16:54:42 <whtspc> really looking forward to lostgeek things too
16:54:51 <ais523> AnMaster: basically in the style of Proud, but saner
16:54:58 -!- puzzlet has quit (Read error: 110 (Connection timed out)).
16:55:02 <ais523> have a huge set of plausible assumptions to start off with
16:55:11 <ais523> then given the current set of assumptions, see which are contradicted by the program
16:55:18 <AnMaster> ais523, Proud, hm was that the uncomputable one?
16:55:23 <ais523> continue iterating until you have a consistent set of assumptions
16:55:36 <ais523> Proud's like I suggested but with an uncountably infinite set of assumptions
16:55:42 <ais523> whereas I was planning just a finite number
16:56:13 <AnMaster> ais523, well, finite would be uh 255 * number of cells! or something like that?
16:56:25 -!- Corun has joined.
16:56:52 <fungot> AnMaster: same core language that the rest of the arguments
16:56:56 <fungot> ^<lang> <code>; ^def <command> <lang> <code>; ^show [command]; lang=bf/ul, code=text/str:N; ^str 0-9 get/set/add [text]; ^style [style]; ^bool
16:57:09 <AnMaster> why didn't it say "out of time"?
16:58:35 <fungot> <CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP> ...
16:58:37 <ais523> ^bf ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
16:58:51 <AnMaster> now that doesn't look right at all
16:58:58 <ais523> the out of stuff thing seems broken
16:59:49 <AnMaster> ais523, seems it fails for "out of cells"
17:00:30 <ais523> AnMaster: that's out of tape too, just off the other end
17:00:37 <fungot> echo reverb rev rot13 rev2 fib wc ul cho choo pow2 source help
17:01:46 <AnMaster> ais523, so how would you implement this optimizer?
17:02:13 <AnMaster> ais523, also what would the assumptions be?
17:02:15 <ais523> AnMaster: I have too many toher things to think about, but I've thought about it before
17:02:26 <AnMaster> ais523, "any cell can have any value"?
17:02:30 <ais523> assumptions like "if the pointer points to this cell, it's location is always known"
17:02:39 <ais523> "every third cell is 0 when this point in the code is reached"
17:02:58 <AnMaster> ais523, yes true, but how do you find out a sane and/or initial set of these assumptions
17:02:58 <ais523> "when the pointer's at cell 3n, n>100, then [<<<] always goes to cell 99"
17:03:10 <ais523> and the initial set is just full of all the assumptions we can think of
17:03:15 <ais523> optimised somehow to save time
17:03:24 <ais523> then it iteratively works out which ones are false
17:03:27 <ais523> until it has a consistent set
17:04:23 <AnMaster> I would do it like tracing the code flow as far as I could then make that constant initial state. For the rest of the code I would have to use another way
17:04:40 <AnMaster> like trying to trace what variables are known at what points
17:05:02 <AnMaster> like as soon as I have a [-] I can know that cell's state until the next bad section
17:05:11 <AnMaster> like unbalanced loop, or input into said cell
17:05:37 -!- KingOfKarlsruhe has quit (Remote closed the connection).
17:05:45 <AnMaster> ais523, that could work very well for gcc-bf output, but would perform rather poorly in the general case
17:06:11 <ais523> AnMaster: yes, probably
17:06:30 <ais523> we'd have to test it on lots of programs to see how real BF programs were generally written
17:06:33 <AnMaster> you would have to create an additional ruleset for the bfbasic or whatever it was called
17:06:43 <ais523> and it would be nice to have it working well on BFBASIC and on gcc-bf
17:06:46 <AnMaster> but for handwritten programs, wouldn't work well
17:07:01 <ais523> AnMaster: why not? handwritten programs mostly use the same sorts of idioms as each other
17:07:16 <AnMaster> ais523, you should be able to add new assumptions
17:07:24 <AnMaster> I mean [-] is too good to miss out on
17:07:36 <ais523> AnMaster: that's not exactly adding a new assumption
17:07:40 <ais523> the assumption would be "pointer is 0 here"
17:07:46 <ais523> and it would never be contradicted
17:07:55 <ais523> so that one would stay in existence throughout the whole analysis
17:07:58 <ais523> not added; just never taken away
17:08:17 <ais523> AnMaster: after the > you have "left of pointer is 0 here"
17:08:28 <ais523> this only works if you have a huge stock of possible assumptions
17:08:49 <AnMaster> ais523, my point is you should be able to trace cell dependencies
17:08:58 <AnMaster> to work out you can turn that into a set to 5
17:08:59 <ais523> it does trace cell dependencies!
17:09:07 <ais523> once you have all the assumptions, then you optimise
17:09:14 <ais523> in this case, you get "pointer is 5 here" at the end
17:09:15 -!- Slereah_ has joined.
17:09:21 <ais523> which is very easy to optimise
17:09:27 <AnMaster> ais523, yes and you need to find where that 5 is used
17:09:36 <ais523> yep, that would have been tracked already too
17:09:58 <jayCampbell> i gave Weave pbrain-style functions last night, haven't uploaded
17:10:10 <AnMaster> you could turn that into, set 0, >, add 7
17:10:15 <jayCampbell> so now it's weave threads + brainfork runtime threads + bprain functions
17:10:22 <AnMaster> ais523, not sure you could make the program do that however easily
17:10:58 <ais523> let's see, I'm thinking
17:11:14 <ais523> before the second [, we have "pointer is 5"
17:11:37 <AnMaster> yep and right of pointer is two more than at the start of the section
17:11:48 <ais523> we can calculate that the loop runs *pointer times
17:12:01 <AnMaster> yes and then we can unroll it,
17:12:02 <ais523> so we can replace it with >+<->+<->+<->+<->+<-
17:12:12 <ais523> and then it's easy from there
17:12:26 <ais523> it would be more interesting if it was >++<+++++[>+<-] without the [-] at the start
17:12:32 <AnMaster> ais523, well the issue with that is, how far ahead should you try to look for merging addition substraction
17:12:43 <AnMaster> think of a 1 MB huge section without any loops
17:12:52 <AnMaster> but where each cell affected is touched several times
17:13:12 <ais523> I think we should probably work at the level of linearisable sections
17:13:12 <AnMaster> but it would be rather expensive for such a long section
17:13:19 <ais523> i.e. sections with balanced <>
17:13:28 <AnMaster> ais523, hm? yes the 1 MB section would have that
17:13:29 <ais523> optimising a 1MB long section without loops is no slower than running it
17:13:32 <ais523> and you only have to optimise it once
17:13:42 <AnMaster> or with loops but balanced ones
17:13:55 <AnMaster> <ais523> it would be more interesting if it was >++<+++++[>+<-] without the [-] at the start <-- how then?
17:14:34 <ais523> AnMaster: well, that becomes pointer[1]+=2; pointer[0]+=1; (pointer[1]+=pointer[0], pointer[0]=0);
17:14:44 <AnMaster> ais523, still I'm not sure this is the smartest way always
17:14:45 <ais523> because it's linearisable, we can track variables separately
17:14:59 <AnMaster> for some balanced loops you might be better off by not unrolling it
17:15:25 <ais523> AnMaster: you can't unroll if you don't know the number of iteratinos
17:15:51 <AnMaster> while (mem[ptr] != 0) { mem[ptr+2]+=4, mem[ptr]--; }
17:16:08 <AnMaster> that could be vectorized by gcc
17:16:13 <ais523> but unrolling is always going to help the optimiser do more optimisations, you can reroll again afterwards
17:16:33 <AnMaster> ais523, how would you re-roll then? not trivial or?
17:17:07 <ais523> rerolling is just run length compression
17:17:19 <ais523> that's what gzip effectively is doing, rerolling loops in text
17:17:47 <AnMaster> for (unsigned char i = mem[ptr]; i != 0; i--); do { mem[ptr+1] += 1; mem[ptr+2] += 1; mem[ptr+3] += 1; }
17:18:00 <AnMaster> that I believe gcc would vectorize probably
17:18:45 <AnMaster> ais523, still I believe there are cases you can gain in by using for
17:19:24 <ais523> well, you can't completely compile a program with loops into a program without in all cases
17:19:43 <ais523> hmm... balanced loops always compile into polynomials, don't they?
17:19:53 <ehird> ais523: bf4 compiles them to polynomials
17:20:22 <ais523> I reckon the best way to make an optimiser would be to always compile the polynomials first
17:20:29 <ais523> then deal with unbalanced loops and assumptions on /that/ level
17:20:44 <AnMaster> ais523, what about turning [[-]>] into a *call* to memset?
17:20:45 <ais523> the assumptions could then mostly be about which cells held zero/nonzero, and where the pointer was
17:21:14 <ais523> AnMaster: you're thinking at a completely different level to me here
17:21:27 <ais523> I'm trying to optimise O(n^2) down to O(n)
17:21:30 -!- whtspc has quit ("ChatZilla 0.9.84 [Firefox 3.0.4/2008102920]").
17:21:33 <ais523> you're optimising O(n) into a slightly faster O(n)
17:22:02 <AnMaster> well turning balanced loops into polynomials first is indeed a good idea
17:22:18 <AnMaster> ais523, but I'm not happy with that
17:22:37 <ais523> AnMaster: well, the usual trick is to let the C compiler do the microoptimisations
17:22:48 <ais523> after the BF compiler has done the computational class optimisations
17:23:00 <AnMaster> ais523, hah, but that requires it to understand what the program tries to do
17:23:06 <AnMaster> which might be far from clear at times
17:23:17 <AnMaster> considering the generated C wouldn't be very typical C code
17:23:32 <ais523> AnMaster: no, it would be the sort of C code that compilers are particularly good at micro-optimising
17:23:43 <ais523> something like [[-]>] into memset is trivial for a compiler like gcc
17:23:50 <ais523> which sees stuff being set to 0 in a loop
17:24:03 <ais523> although, that would only work if the end was known
17:24:09 <AnMaster> so it would turn it into a strlen + a memset?
17:24:17 <ais523> strlen + memset is slower than just looping
17:24:19 <AnMaster> since memset is faster than setting each byte
17:24:31 <AnMaster> ais523, depends, consider that memset can set 32 or 64 bits at a time
17:24:36 <ais523> the fastest way would be to do it wordwise
17:24:37 <AnMaster> while looping would just set 8 at a time
17:24:47 <AnMaster> ais523, indeed, which is what memset does iirc
17:25:05 <AnMaster> well I don't know what asm it uses
17:25:12 <ais523> memset doesn't terminate at end of string
17:25:25 <ais523> you want a string-set instruction, not a memory-set instruction
17:25:28 <AnMaster> that is crazy x86 string instruction things?
17:25:34 -!- Judofyr has joined.
17:25:39 <ais523> I'm pretty sure there's one that does exactly [[-]>]
17:25:44 <AnMaster> ais523, I wouldn't know, I'm writing portable code
17:25:51 <ais523> AnMaster: well, exactly
17:25:56 <ais523> this is why you let the compiler worry about the details
17:26:20 <AnMaster> ais523, about that rep stuff, can those be interrupted and resumed in the middle?
17:26:29 <AnMaster> how it works with context switches
17:26:29 <ehird> an insane BF optimizer would compile down to machine code
17:26:44 <ais523> AnMaster: yes, but you need to keep track of the registers
17:26:56 <ais523> IIRC, they put their internal state in CX or something like that
17:27:00 <AnMaster> ais523, well the OS dumps them right
17:27:09 <ais523> SI, DI, and CX, or something
17:27:16 <ais523> so if the OS dumps them, it can resume the instruction
17:27:20 <AnMaster> ais523, only 16 bit registers?
17:27:30 <AnMaster> that sounds like it could be an issue
17:27:34 <ais523> AnMaster: I learnt x86 asm on DOS
17:27:41 <ais523> it works with bigger registers almost certainly
17:28:01 <ais523> but I have trouble thinking about anything bigger than 16 bits as I never learnt x86 asm in protected-mode
17:28:11 <ais523> just good old-fashioned real-mode programming
17:28:28 <AnMaster> makes it operate on 64-bit operands
17:29:22 <AnMaster> ais523, anyway, what about constant folding too?
17:29:34 <ais523> constant folding would happen automatically
17:29:38 <AnMaster> could be done for parts inside loops
17:29:40 <ais523> it's really the basis behind the whole thing
17:29:52 <AnMaster> that I think would be a good idea
17:30:16 <AnMaster> if the program starts with filing in lots of cells with initial values, you could constant fold that and put it in a static array
17:30:38 <AnMaster> probably even use the static array for the first section of memory
17:30:57 <AnMaster> we can't know the memory we get allocated are in one block
17:31:04 <AnMaster> the OS could allocate with holes
17:31:07 <ais523> wow, I just realised why UK keyboards have ¬ and that weird broken-vertical-bar char on them
17:31:21 <ais523> it's because they're the printable characters in EBCDIC that aren't in ASCII
17:31:22 <AnMaster> ais523, and to handle holes you need a more complex pointer
17:31:39 <ais523> that way, UK keyboards can type all the printable chars in ASCII, and all the printable chars in EBCDIC
17:31:58 <AnMaster> ais523, well anyway, what about the issue I mentioned?
17:32:22 <AnMaster> I would try to mmap() pages probably, but what if they are not in one single block
17:32:27 <ais523> AnMaster: gcc-bf spends the whole first part of the program going >>>>>>>>>>>+++++++++++++>>>>>>>+++++>>>>>>>>>>>>>>>>>>>+++++++++++++
17:32:38 <ais523> and memory doesn't have holes if you don't ask for it with holes
17:32:40 <AnMaster> ais523, indeed that could be constant folded
17:32:48 <ais523> AnMaster: it's intended to be
17:32:48 <AnMaster> ais523, how do you mean? realloc()?
17:32:54 <AnMaster> but what if it needs to be moved
17:33:02 <ais523> AnMaster: there is no problem with realloc moving stuff
17:33:15 <AnMaster> ais523, yes it would be for something with a large data set
17:33:18 <ais523> AnMaster: well, if you're really crazy, use sbrk
17:33:27 <ais523> it's perfect for allocating data for Brainfuck
17:33:39 <ais523> although almost useless for most langs
17:33:43 <AnMaster> ais523, hm that depends on knowing nothing else is malloced there
17:33:52 <ais523> but avoiding malloc is easy enough, surely?
17:33:55 <AnMaster> say if I call putchar() how can I know it didn't just malloc() something
17:34:06 <ais523> AnMaster: isn't there a guarantee somewhere about that?
17:34:14 <ais523> it wouldn't surprise me if there was
17:34:22 <AnMaster> ais523, don't think so, glibc allocs a lot of internal stuff I'm pretty sure
17:34:59 <AnMaster> ais523, yes indeed, so suddenly sbrk may mean it isn't at the top any more!
17:35:18 <ais523> well, you could do brk(NULL) to see if the break value had unexpectedly changed
17:35:24 <ais523> and just realloc the whole lot if it had
17:35:38 <ais523> if something's going to insist on making memory discontiguous, you're going to have to move things around to recontiguise it
17:35:40 <AnMaster> that could leave a huge unused area below
17:36:05 <ais523> AnMaster: you're still thinking on entirely the wrong level here
17:36:17 <ais523> if you really really want massively optimised code, just refrain from syscalls
17:36:20 <AnMaster> ais523, also I'm not sure libc isn't allowed to see there is something free below sbrk and alloc stuff there
17:36:30 <ais523> that way you know that nothing's brking behind your back
17:36:34 <AnMaster> ais523, you need syscalls for input and output
17:36:47 <ais523> AnMaster: no you don't!
17:36:52 <ais523> the operating system has to manage it somehow
17:37:20 <AnMaster> ais523, ah I got an idea, elf hack, and no idea if it works for stuff in libc
17:37:31 <AnMaster> to something that allocs from mmaped areas
17:37:41 <AnMaster> well valgrind doesn't do that bit
17:37:54 <AnMaster> anyway it probably won't work for internall malloc() calls in the libc
17:37:58 <ais523> AnMaster: it does work for stuff in libc
17:38:13 <ais523> valgrind errors on some stuff on libc, or would do if it wasn't careful not to
17:38:19 <ais523> besides, just link libc statically
17:38:22 <AnMaster> ais523, wouldn't it use a direct call instead of going through the symbol table?
17:38:26 <ais523> then it definitely works
17:39:13 <AnMaster> ais523, and this would probably only work on a few *nix like linux
17:39:26 <ais523> AnMaster: you are thinking on utterly utterly the wrong level, OK
17:39:40 <AnMaster> well I agree high level optimizations is best
17:39:54 <AnMaster> but once that is done you want more speed
17:40:19 <AnMaster> ais523, it isn't enough to be fast, you will want to be fastest
17:40:36 <AnMaster> just to make sure no one can sneak up easily on your speed
17:41:47 <ais523> AnMaster: but any number of low-level optimisations will fail to a big optimisation at the top that improves computational order
17:41:53 <ais523> also, low-level optimisations often slow things down
17:42:12 <AnMaster> ais523, indeed you should do the big optimisations first
17:42:22 <AnMaster> and once that is done, continue with lower and lower levels
17:42:46 <ais523> but things like ensuring that all the memory in a BF interp is contiguous are completely independent of other optimisations
17:42:50 <ais523> and I don't really care about them right now
17:43:01 <ais523> besides, all the BF interps in existence have never really had problems with that
17:43:17 <ais523> if you want contiguous memory, allocate a few MB worth of cells in a static array
17:43:34 <ais523> as in practice people never go off the end of that anyway, if they do, don't care about the time delay on realloc
17:43:44 <ais523> AnMaster: no I don't, ask ehird
17:43:52 <ehird> ais523: how, I have him on ignore
17:43:59 <ais523> ehird: AnMaster wants a link to bf4
17:44:13 <ehird> ais523: ouch. it must suck being in an alternate universe without google for him.
17:44:19 <ehird> or the esolang wiki
17:44:25 <ais523> [17:44] <AnMaster> I did google yes
17:44:27 <ais523> [17:44] <ehird> ais523: ouch. it must suck being in an alternate universe without google for him.
17:44:44 <ehird> <ehird> or the esolang wiki
17:44:48 <ais523> perfect timing on that, AnMaster answering ehird's complaint before ehird complained it...
17:44:49 <ehird> today on the ais523 show we snip context
17:44:56 <ais523> ehird: it was just two lines in a row
17:45:02 <ais523> that was post-context I snipped
17:45:12 <ehird> no, it was a sentence over two lines
17:45:30 <AnMaster> wow it isn't on the brainfuck page
17:45:33 <ais523> ehird: besides, AnMaster clearly doesn't live in a world without Google or Esolang, as he lives at least in a world with Google
17:46:08 <ais523> also, according to AnMaster it isn't on http://esolangs.org/wiki/brainfuck either
17:46:13 <AnMaster> can not be found on the brainfuck esolang page
17:46:57 <AnMaster> if it got another name it would he hard to find...
17:47:05 -!- jix_ has joined.
17:47:12 -!- jix_ has quit (Remote closed the connection).
17:47:13 <ais523> ehird: there are no instances of the digit 4 anywhere on http://esolangs.org/wiki/brainfuck
17:47:21 <ais523> wait, messed up my browser
17:47:26 -!- jix_ has joined.
17:47:27 <AnMaster> ais523, well there is, "This page has been accessed 47,617 times."
17:47:32 <ehird> it isn't named in the link
17:47:36 <AnMaster> and Brainfuck interpreter for the HP48gII calculator. May also work with other HP calculators.
17:47:46 <ais523> ehird: well, then why did you expect AnMaster to find it by searching Esolang
17:47:55 <AnMaster> ok then how the heck should you find it... if it badly named
17:48:00 <ehird> He could look at the link text and click ones that look relevant?
17:48:01 <ais523> you're arguing against yourself here
17:48:02 <ehird> That's how I found it.
17:48:27 <ais523> ehird: that's much less reasonable than asking someone who knows the link to tell where it is
17:48:40 <ehird> Well, yes, but you could go for someone who wants to tell you,.
17:48:46 <ais523> you're coming up with a rather beware of the leopard response
17:50:24 <AnMaster> it is a lot more fun to optimize brainfuck than it is to code in it, IMO
17:52:10 -!- puzzlet_ has quit (Remote closed the connection).
17:52:15 -!- puzzlet has joined.
17:53:00 <AnMaster> ok with some googling I found this http://mozaika.com.au/oleg/brainf/
17:53:28 <AnMaster> well that wasn't the name ehird told us initially
17:53:46 <AnMaster> now if he had said that it would have been simpler
17:53:50 <ais523> ehird: AnMaster says that the interp in question is actually called bff4
17:53:56 <ais523> so you even got the name you told em wrong
17:54:04 <ehird> not exactly hard to make the leap?
17:54:09 <ais523> ehird: well, yes it is
17:54:16 <AnMaster> yes, why would I try to look for an extra f?
17:54:20 <ais523> would you claim that bf and bff are the same interp?
17:54:28 <ehird> no, but the 4 is the main thing
17:54:55 <ais523> ehird: that's a version number... naming programs including the version number is fine, naming programs after /just/ the version number is stupid
17:55:05 <ehird> ais523: It is not a version number.
17:55:07 <ais523> unless the version number itself is something stupid like XP or Vista
17:55:22 <AnMaster> ais523, someone else made bff it says on that page
17:55:36 <AnMaster> how could I guess there was an extra f?
17:55:46 <AnMaster> I mean, it isn't in the name "brainfuck
17:56:11 <AnMaster> so how on earth would it be possible to guess that one should add the extra f
17:56:49 <ais523> ehird: <http://www.google.co.uk/search?q=brainfuck+4&ie=utf-8&oe=utf-8&aq=t&rls=com.ubuntu:en-US:unofficial&client=firefox-a>, Google disagrees with you on the 4 being the main thing
17:57:03 <ais523> if it was, a Google search for "brainfuck 4" would find what you were talking about
17:57:04 <ehird> seriously, stop bugging me.
17:57:12 <AnMaster> sure ehird, but you didn't say it at the start
17:57:16 <ehird> it's very obvious i don't feel like helping AnMaster.
17:57:20 <ais523> ehfird: why on earth would you assume people would randomly add an extra 4 to things?
17:57:38 <ehird> that wasn't a regexp.
17:57:41 <AnMaster> and also just admitting the mistake would be easier
17:57:55 <ais523> ehird: well, clearly, it's a syntax error as a regexp
17:58:06 <AnMaster> also he didn't say that initially
17:58:09 <ais523> it's legal but pointless as a wildmat
17:58:26 <ais523> AnMaster: don't be too hard on ehird, his keyboard obviously has an invisible f key button that he pressed by mistake
17:58:31 <ais523> being invisible, he didn't realise
17:58:39 <ais523> those Apple keyboards are strange...
17:58:53 <ehird> k, call me back when you're talking about esolangs instead of lolling with AnMaster about me, i kind of have better things to do than being highlighted every 2 seconds
17:58:55 -!- ehird has left (?).
17:59:00 <AnMaster> ais523, so you mean he got one normal and one invisible f?
17:59:11 <AnMaster> also he can't simply admit he did a mistake
17:59:11 <ais523> as he's obviously capable of typing visible fs
17:59:25 <ais523> AnMaster: actually, he seems to have admitted he was being deliberately obstructive to try to annoy you
17:59:39 <ais523> which makes complaining about the resulting revenge a bit rich
18:00:39 <AnMaster> ok the bff4 code isn't very well commented
18:00:47 <AnMaster> http://mazonka.com/brainf/bff4.c
18:01:14 <AnMaster> one helpfull thing is that -DLNR is supposed to be what makes it optimize linear loops
18:01:35 <AnMaster> so hopefully not to hard to find the relevant code that way
18:02:01 <AnMaster> for( i=0; i<z->sz; i++ ) m[mp+z->off+i]+=del*z->d[i];
18:02:14 <AnMaster> it calculates if it is linear a bit before
18:02:20 <ais523> AnMaster: I'm too busy with other things to attempt to parse that code, I think
18:02:32 <AnMaster> ais523, a bit obfuscated isn't it
18:02:42 <ais523> meaningless variable names, not enough spaces
18:02:54 <ais523> it's slightly worse than what I write on average, which means it must be /really/ bad
18:03:13 <AnMaster> ais523, the whole file is like that
18:03:21 -!- psygnisfive has joined.
18:03:29 <AnMaster> ais523, after the includes there is *NO* comment
18:03:51 <ais523> I comment my code quite a bit normally
18:03:54 <ais523> especially the obfuscated code
18:04:03 <ais523> even the IOCCC stuff is commented, although the comments are just there to confuse people
18:04:07 <ais523> with the * on the next line
18:04:55 <AnMaster> ais523, also bff4 seems to be an interpreter not a compiler
18:05:15 <ais523> it's basically a bytecode compiler + interpreter, I think
18:09:41 <AnMaster> ais523, hm would it be possible to optimize > or < into a constant goto cell after an unbalanced loop?
18:09:46 <AnMaster> what would be needed to be able to
18:09:56 <AnMaster> setting pointer to a fixed value
18:10:08 <AnMaster> not like adding or subtracting a specific value
18:10:47 <ais523> <AnMaster> ais523, hm would it be possible to optimize > or < into a constant goto cell after an unbalanced loop? <--- that's the main thing I want to focus on
18:11:15 <AnMaster> you could make a balanced one too
18:11:36 <ais523> [>.<-] is trivially translated
18:11:44 <ais523> it just prints a character lots of times
18:12:04 <ais523> that just reads characters forever, doesn't it?
18:12:04 <AnMaster> or , that ends up affecting loop count
18:12:11 <AnMaster> but where you can still know the cell
18:12:29 <AnMaster> ais523, hm ok, so what about one where it substracts 78 from the value it read?
18:12:33 <ais523> AnMaster: things like ,[.,] probably can't be optimised any furthre
18:12:40 <AnMaster> that could be easily input and hit 0
18:13:33 <AnMaster> then if I enter N the loop will ned
18:13:38 <AnMaster> but anything else it will continue
18:13:50 <AnMaster> sure that is hard to optimize more
18:13:59 -!- oerjan has joined.
18:14:10 <AnMaster> that would be easy to optimize with known iteration count
18:14:20 <AnMaster> but you can no longer do anything but a while loop
18:14:35 <ais523> AnMaster: there is nothing intrinsically bad about while loops
18:14:44 <ais523> it's the number of nested loops you want to be able to keep down in a program
18:15:10 <AnMaster> but still user input affecting the loop counter might be hard to handle
18:15:15 <ais523> AnMaster: no it isn't, just do a while loop
18:15:20 <ais523> that's what it /is/, after all
18:15:32 <ais523> it doesn't block the sort of high-level optimisations I care about, just your low-level parallelised megafors
18:15:43 <AnMaster> ais523, true, but you know what I saw recently, with gcc, a while loop used for comping CRC, was slow
18:16:08 <AnMaster> and yes object size was known at compile time in both cases
18:16:11 <ais523> AnMaster: is "a lot" a factor of 10000 or more?
18:16:26 <AnMaster> ais523, a lot being like a factor or 4 times as fast or so
18:16:27 <ais523> it's the factor-of-10000 changes I'm going for
18:17:16 <AnMaster> ais523, since it was run several hundred of thousands of times during a single execution however
18:17:36 <AnMaster> it was at the top of "time spent in function" in gprof output
18:18:01 <ais523> anyway, I'd like to end this conversation, so I can concentrate on something else
18:18:07 <ais523> I have a massively long email to reconstruct
18:18:11 -!- Deewiant has quit (Read error: 60 (Operation timed out)).
18:18:21 <AnMaster> ais523, meanwhile I will try to work on some ideas I got from this convo
18:18:28 -!- oerjan has quit (Client Quit).
18:18:44 <oklopol> and i will go to el shoppo
18:19:05 <oklopol> optimizing bf again i see, i gutta read the context when i returnn
18:26:34 <AnMaster> oklopol, we had some new ideas
18:27:38 -!- Deewiant has joined.
18:27:50 -!- ineiros has quit (Read error: 101 (Network is unreachable)).
18:39:01 <AnMaster> Deewiant, ais523: good name for the project?
18:39:36 <AnMaster> Results 1 - 10 of about 704,000 for bf4. (0.17 seconds)
18:41:41 -!- Slereah_ has quit (Read error: 113 (No route to host)).
18:42:02 <AnMaster> Results 1 - 8 of 8 for bf4 brainfuck. (0.05 seconds)
18:42:16 <AnMaster> and the interpreter with the same name is crap it seems
18:45:26 <ais523> I don't really put much stock in Google
18:57:32 -!- oerjan has joined.
19:06:24 * oerjan wonders what went into that
19:06:52 <oerjan> and will the successor be called befyve?
19:08:00 <oerjan> is this an interpreter for ordinary bf, or is there something extra?
19:09:24 <oerjan> you broke the chain :(
19:10:10 <oklopol> a bitta glio never hurt anyone
19:10:30 <ais523> oerjan: it was a very short chain...
19:10:34 <AnMaster> it will implement some new ideas that ais523 and me discussed above
19:10:42 <oerjan> ais523: killed in its infancy :(
19:10:52 <oklopol> ais523: i think oerjan extrapolated it'd be a long conversation.
19:11:04 <oklopol> but then i had to come and steal focus
19:11:15 <AnMaster> ais523, hahah at function name: before_postprocess
19:11:46 <oerjan> oklopol: that's preposterous
19:12:04 <AnMaster> "static inline void before_init(void) {",
19:12:04 <AnMaster> " cells = malloc(CHUNKSIZE * sizeof(beforecell));",
19:12:04 <AnMaster> " memset(cells, 0, cellcnt * sizeof(beforecell));",
19:12:19 <AnMaster> I based this on the def-bf compiler I was working on
19:12:29 <AnMaster> except pikhq never finished his high level part
19:12:35 <AnMaster> so I consider the def-bf stuff dead
19:12:39 <oklopol> no one ever finishes anything
19:12:45 <oerjan> oklopol: actually the second google hit on glio is on someone who died from it :/
19:13:01 <AnMaster> "static inline void before_cleanup(void) {",
19:13:07 <psygnisfive> anyone ever done any machine learning stuff? :T
19:14:30 <oklopol> oerjan: most hilarious death of the day, even more fun than your chain.
19:15:01 <oerjan> apparently it was an abbreviation of glioblastoma
19:15:50 <oklopol> yes, who doesn't like cancer
19:16:25 <oerjan> now i still wonder what oklopol meant by glio
19:17:05 <oklopol> oerjan: stop getting my sarcasm, you're ruining all the AnMaster from me.
19:17:34 <oerjan> oh i didn't see your "yeah that's what i meant"
19:19:28 <oerjan> lessee, there's a User:Glio on wikimedia
19:19:54 <AnMaster> ^bf >>,[[-<++>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[<[-]+>->+<[<-]]]]]]]]]]>]<<[>++++++[<++++++++>-]<-.[-]<]++++++++++.[-]>>,]!test
19:20:06 <AnMaster> ^bf >>,[[-<++>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[<[-]+>->+<[<-]]]]]]]]]]>]<<[>++++++[<++++++++>-]<-.[-]<]++++++++++.[-]>>,]!hm nice very nice
19:20:07 <fungot> 104.109.32.110.105.99.101.32.118.101.114.121.32.110.105.99.101.
19:20:14 <AnMaster> ^bf >>,[[-<++>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[<[-]+>->+<[<-]]]]]]]]]]>]<<[>++++++[<++++++++>-]<-.[-]<]++++++++++.[-]>>,]!9
19:20:38 <oerjan> oklopol: of course i was hoping you were fluent in the Glio-Oubi language
19:27:24 <AnMaster> already the not very much optimizing compiler is twice as fast as bff4
19:27:37 <AnMaster> I guess the fact that it is compiled is the cause
19:27:45 <ais523> AnMaster: wow, that's pretty good
19:28:05 <AnMaster> ais523, was testing on mandelbrot.b
19:28:08 <ais523> ok, probably it depends on the program you run it on then
19:29:00 <AnMaster> ais523, was using gcc -march=k8 -msse3 -O3 -ftree-vectorize for both bff4 and the source my compiler generated
19:29:18 <fizzie> +[>+] should terminate when the first cell wrap-arounds; that's just some 3*256000 instructions. Well, I guess it should time-out before that, actually.
19:29:21 <AnMaster> $ gcc -Wall -Wextra -march=k8 -msse3 -O3 -ftree-vectorize -DLNR -o bff4 bff4.c
19:29:24 <ais523> AnMaster: I'd argue that your compiler is not at all faster than bff4
19:29:31 <ais523> just you're using better compiler options
19:29:35 <ais523> and a better implementatino
19:29:46 <AnMaster> ais523, I'm using the same options for both
19:30:03 <AnMaster> $ gcc -Wall -Wextra -march=k8 -msse3 -O3 -ftree-vectorize -o mandelbrot mandelbrot.c
19:30:04 <ais523> well a compiler's always going to beat the interpreter unless the interpreter manages to optimise stuff a lot
19:30:27 <AnMaster> ais523, but this makes it very very hard to compare
19:30:54 <ais523> AnMaster: how do they compare on Lost Kingdoms startup?
19:31:39 <fizzie> Seems that my timeout limits are not very strict.
19:31:57 <ais523> ^bf +[>+]++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
19:32:13 <ais523> fizzie: how do you explain that?
19:32:19 <ais523> it's executing the code after +[>+]
19:32:19 <AnMaster> ais523, waiting for gcc to compile lostkingdom
19:32:22 <ais523> which is really strange
19:32:33 <ais523> AnMaster: ah, I forgot about that...
19:32:36 <fizzie> ais523: Why not? +[>+] terminates when one cell wrap-arounds.
19:32:47 <AnMaster> ais523, well I removed the case stuff
19:32:56 <ais523> it sets each cell to 1 on the entire atpe
19:32:58 <AnMaster> but it still manages to be very slow
19:32:58 <fizzie> I have a 1000-cell tape which wraps, and one-byte cells.
19:33:06 <ais523> fizzie: oh, the tape wraos?
19:33:17 <ais523> no wonder we couldn't get it to display an out-of-tape message
19:34:00 <AnMaster> $ gcc -std=c99 -E -o tmp.c LostKng.c
19:34:38 <fizzie> Yes, there's no infinite tape in fungot's brainfuck. Isn't a fixed-size memory quite common for brainfuck?
19:34:44 <fizzie> fungot: Well excuse me!
19:34:45 <fungot> fizzie: let's just pretend that it's necessary :) at least i have. :) ( and i'm not sure what
19:34:57 <AnMaster> ais523, bff4 exists on lostkingdom
19:35:38 <AnMaster> read(0, "#!/usr/bin/bf\n\n# Name : Lost"..., 2048) = 2048
19:36:27 <ais523> AnMaster: why did you just paste that?
19:36:32 <ais523> also, what is exit_group?
19:36:42 <ais523> and brk seems to be acting entirely sanely there to me
19:37:02 <AnMaster> ais523: since I don't know how to feed input to a program running under gdb from a pipe
19:37:29 <ais523> AnMaster: gdb has a command-line arg for that, IIRC
19:38:17 <ais523> I don't remember what it is either
19:39:42 <ais523> ! means end of program, start of input
19:39:47 <ais523> in BF programs which take them in the same stream
19:40:22 <AnMaster> this means I have to paste all of lostkingdom on it's stdin
20:11:26 -!- oklopol has quit (Connection reset by peer).
20:11:48 <AnMaster> damn I need an integer that can also be unset
20:11:56 <AnMaster> and I can't reverse any special value
20:12:09 <ais523> AnMaster: define a Maybe Integer
20:12:23 <ais523> although this requires you to use a programming language, like Perl with Moose or Haskell, in which they exist
20:12:27 <AnMaster> ais523, and the size is important
20:12:34 <ais523> can't you use the next size up?
20:12:49 <AnMaster> ais523, well no this is for tracking offset of cells within loop
20:12:53 <ais523> AnMaster: well you can't fit 32 and a fraction bits into a 32-bit variable
20:13:11 <ais523> you could have a separate one-bit variable which tracks whether it's set or not
20:13:27 <ais523> and if it's ssize_t, why not use the minimum possible value as exceptional?
20:13:32 <AnMaster> ah yes let me look at padding in struct
20:13:49 <AnMaster> ais523, but what if someone adds that many > on a 32-bit platform?
20:14:01 <ais523> AnMaster: you can only compare them one way round is the point
20:14:18 <ais523> ssize_t can only cover half the memory space as it is
20:14:41 <AnMaster> well I guess the situation should never
20:14:47 <AnMaster> and I could document the issue
20:14:58 <ais523> sounds like you really want a 33-and-a-fraction-bit variable
20:15:15 <AnMaster> ais523, I also yes and an union to not waste spaec
20:15:16 <ais523> but the minimum value wouldn't even exist except on a 2's complement machine
20:15:27 <ais523> it's equal to 0-itself, anyway, so doesn't act sanely with arithmetic
20:15:32 <ais523> that's why it makes a good exceptional value
20:15:37 <ais523> AnMaster: the value with bit pattern 100000000000000000000000000000000
20:16:25 <ais523> it's the opposite of -0
20:16:31 <ais523> it's as far from 0 as you can get
20:16:47 <ais523> rather than -0 which arithmetically works the same way as 0
20:16:52 <AnMaster> ais523, that would be FOO_MIN right?
20:16:57 <AnMaster> assuming there is one for ssize_t
20:17:44 <ais523> it has to be defined like that
20:17:56 <ais523> say, SHORT_MIN can't actually be -32768
20:18:27 <ais523> because - is an operator, and 32768 needn't neccessarily fit in an int
20:18:29 <AnMaster> ais523, a grep shows SHORT_MIN isn't defined either
20:18:44 <ais523> some stupid abbreviation from decades ago
20:19:03 <ais523> is that an attempt at a joke?
20:19:14 <AnMaster> ais523, yes a *short* form of *short*
20:19:41 <ais523> /usr/include/limits.h:# define LONG_MIN(-LONG_MAX - 1L)
20:20:04 <ais523> although my headers define SHORT_MIN as -32768 directly, because they know they're for a 32-bit system
20:20:18 <ais523> the same thing applies to all integer sizes, just I can't remember the relevant power of 2
20:20:41 <oerjan> AnMaster: it was a reasonably good joke until you explained it :D
20:20:50 <AnMaster> oerjan, well I had to for ais523
20:20:57 <ais523> AnMaster: actually, I got it
20:21:06 <ais523> just wasn't sure if you were joking deliberately or not
20:21:26 <AnMaster> now I am normally THAT bad at jokes really?
20:21:37 <oerjan> so, why isn't it LONG_MAXIMUM?
20:21:53 <ais523> AnMaster: it's -SSIZE_MAX-1
20:21:57 <ais523> if SSIZE_MAX is defined
20:22:01 <AnMaster> ais523, on 2 complement at least
20:22:01 <ais523> and you're on a two's complement system
20:22:06 <ais523> which given your stupid optimisation you are
20:22:17 <AnMaster> ais523, but how would i know I am?
20:22:21 <AnMaster> I'm just trying to count index
20:22:24 <ais523> hmm... why not detect the representation at compile-time
20:22:33 <ais523> and use SSIZE_MIN as your exceptional value on 2's complement
20:22:35 <AnMaster> ais523, as in "this is offset two from start of loop"
20:22:38 <ais523> and -0 on 1's complement
20:22:47 <ais523> AnMaster: why not use unsigned size_t, the?
20:23:03 <ais523> also, rely on the fact that the loop can't possibly take up all of memory due to the final ]
20:23:11 <ais523> thus you can safely use SIZE_MAX as your exceptional value
20:23:23 <ais523> AnMaster: measure offset from the start of the program instead, then
20:23:41 <ais523> (there's also the fact that the compiler itself has to be in memory somewhere, but that isn't as funny)
20:23:50 <AnMaster> anyway: not easy if there is an unbalanced loop
20:23:54 <ais523> AnMaster: instead of taking the offset from one place to another
20:24:11 <ais523> I thought you meant offset in program
20:24:21 <AnMaster> the stuff have already been mangled a bit by this point
20:24:26 <AnMaster> however I'm unsure about order
20:24:48 <AnMaster> that is the order that I should do various reductions
20:25:19 <AnMaster> should I try to handle >><< first, then the tape offset, then [-]
20:25:35 <AnMaster> it doesn't seem trivial to combine them
20:26:03 <AnMaster> except [-] shouldn't be done first
20:26:18 -!- puzzlet has quit (Read error: 60 (Operation timed out)).
20:26:28 <AnMaster> which the tape offset would manage to turn into [-]
20:26:35 <AnMaster> which then could be turned into set 0
20:26:44 <AnMaster> or should I do multiple passes with each optimizer?
20:27:04 <ais523> AnMaster: C-INTERCAL does multiple passes
20:27:04 <AnMaster> I want to catch all cases I can catch
20:27:07 <ais523> until nothing more is optimised
20:27:09 <ais523> that's probably the best way
20:27:28 <AnMaster> ais523, I already avoid multiple passes with >><< reduction
20:27:35 <AnMaster> by stepping one step backwards
20:28:05 <AnMaster> without that I would get: 2- 1+
20:28:41 -!- puzzlet has joined.
20:38:37 -!- warrie has joined.
20:39:37 <warrie> How dare you disturb my hallucinations.
20:40:12 <ais523> warrie: we're now debating whether or not 3=4
20:40:16 -!- Deewiant has quit ("Viivan loppu.").
20:40:16 <ais523> ehird seems to think it is, for some reason
20:40:20 <oerjan> hi warrie, did you know your nick is a prime in base 256?
20:40:29 <ais523> also, we're debating whether 4 increased by 1 is 5
20:40:43 -!- Deewiant has joined.
20:40:43 <oerjan> haven't checked yet :D
20:40:57 <ais523> oerjan: "warrie" is even in base 256
20:41:15 <ais523> going by the hex 0-9a-f thing but extended
20:41:20 <ais523> then you get a, c, e as even
20:41:23 <oerjan> of course i'm using ascii
20:42:19 <warrie> The derivative of |x| with respect to x is |x| divided by x, right?
20:42:42 <ais523> yes, that's one way to put it
20:42:52 <ais523> it's undefined at 0, though, rather than infinite
20:42:54 <warrie> Still true in the complex numbers and all?
20:43:00 <ais523> although whether this makes a difference depends on how pedantic you are
20:43:04 <warrie> |0|/0 is not very infinite.
20:43:15 <ais523> warrie: well, it's a NaN
20:43:34 <ais523> arguably that's decent for an undefined derivative
20:43:35 <oerjan> darn it's divisible by 5
20:44:04 <warrie> I'll do the Chain Rule Test.
20:44:57 <oerjan> warrie: |x| is surely not analytic so complexes are not nice
20:45:26 <AnMaster> I need to track offset from what anyway
20:45:38 <AnMaster> so that one is NULL or a node pointer
20:45:45 <AnMaster> I'm not sure how sane this is...
20:47:16 <warrie> -i = |i|/i = d|ix|/dx = d|ix|/d(ix)*d(ix)/x = |ix|/(ix) * i = |x|/x... yeah, I forgot that you can't differentiate |x| over the complex numbers.
20:47:45 <oerjan> warrie: you might check it in the x direction
20:48:38 <warrie> I'll just use "undefined".
20:52:08 <ais523> gah, this is annoying: I found an interesting obfuscated quine on a webpage, but it doesn't give the program, just an example of its output
20:53:06 <warrie> I hate it when you know a quine's output but not its source code.
20:53:49 <AnMaster> is using memset(foo, 0, sizeof(foo_t));
20:53:51 -!- Deewiant has quit ("Viivan loppu.").
20:54:11 -!- Deewiant has joined.
20:54:13 <AnMaster> a safe way to ensure are pointers in said struct are all NULL?
20:54:16 <warrie> What is an obfuscated quine, by the way?
20:54:27 <fizzie> Of course not, since all-bits-zero is not necessarily NULL.
20:54:46 <fizzie> Not that people wouldn't do that sort of stuff anyway.
20:54:52 <ais523> warrie: something which isn't obviously a quine
20:54:57 <ais523> although this one's just a meaning-quine
20:55:05 <ais523> in that it outputs a program that does the same thing as it
20:55:09 <ais523> but isn't necessarily the same
20:55:12 <ais523> several programs, in fact
20:55:41 <oerjan> AnMaster: 4714790940847662450
20:56:07 <oerjan> and divisible by 5 that too
20:56:56 <oerjan> i used haskell: readInt 256 (const True) (fromEnum) "AnMaster"
20:57:10 <AnMaster> oerjan, well that doesn't answer the question
20:57:12 <oerjan> (requires Numeric module)
20:57:24 <AnMaster> oerjan, what is the mathematical mapping?
20:57:47 <AnMaster> you just pointed at a black box
20:57:51 <oerjan> i guess that befunge thing is the same
20:58:48 <AnMaster> oerjan, is that how you do it?
20:58:58 <oerjan> that should be equivalent yes
20:59:13 <oerjan> except readInt uses an actual multiplication by 256
20:59:31 <oerjan> (since it is not restricted to powers of 2)
20:59:35 <AnMaster> oerjan, it should be 0x4346554e
20:59:42 <fizzie> "fizzie" is 112603212441957 = 3*1747*20897*1028141. I'm "almost prime", for some values of "almost".
21:00:06 <AnMaster> 112603212441957: 3 1747 20897 1028141
21:00:19 <AnMaster> <oerjan> except readInt uses an actual multiplication by 256
21:00:19 <AnMaster> <oerjan> (since it is not restricted to powers of 2)
21:00:26 <AnMaster> that is odd, doesn't ghc optimize?
21:00:34 <ais523> fizzie: so what is the value of "almost"?
21:00:45 <ais523> AnMaster: Int and Integer are different types in Haskell
21:00:50 <fizzie> ais523: In this case, "not really, but sorta".
21:00:54 <oerjan> AnMaster: it's 0x416e4d6173746572
21:01:10 <AnMaster> no then you use some totally different way
21:01:22 <AnMaster> oerjan, and what is CFUN in your system
21:01:30 <AnMaster> <AnMaster> oerjan, so CFUN is?
21:01:32 <AnMaster> <AnMaster> oerjan, it should be 0x4346554e
21:01:43 <AnMaster> <oerjan> AnMaster: it's 0x416e4d6173746572
21:01:53 <AnMaster> oerjan, doesn't make sense does it?
21:02:22 <ais523> AnMaster: that string oerjan pasted is "AnMaster", I think
21:02:43 <ais523> that 72 at the end looks wrong
21:02:44 <AnMaster> I do have a convert the other way for 32-bit routine somewhere around here
21:02:49 <ais523> oh, ofc, there are more than 16 letters in the alphabet
21:02:53 <ais523> so yes, probably AnMaster
21:03:17 <AnMaster> fungeCell fprint = ImplementedFingerprints[i].fprint;
21:03:17 <AnMaster> char fprintname[5] = { (char)(fprint >> 24), (char)(fprint >> 16),
21:03:17 <AnMaster> (char)(fprint >> 8), (char)fprint, '\0'};
21:03:28 <AnMaster> that very much depends on it being max 32-bit
21:04:00 <oerjan> AnMaster: i thought by CFUN you meant some technical abbreviation meaning "fingerprint notation"
21:04:14 <AnMaster> oerjan, no it is the handprint of cfunge
21:04:23 <fizzie> perl -e 'use bignum; $x = 256*$x + ord($_) foreach split //, "fizzie"; print $x, "\n";'
21:04:31 <AnMaster> with some type punning it should be faster
21:04:31 <fizzie> The perly thing is less pretty than Haskell. Surprise!
21:04:36 <AnMaster> to just store it as an integer
21:05:02 <ais523> also, I've been writing a lot of Prolog recently
21:05:04 <AnMaster> I assume strict aliasing rules
21:05:09 <ais523> and decided that Prolog is really pretty
21:05:17 <ais523> and at least as reflective as Smalltalk
21:05:20 <AnMaster> except in 3 places: FPDP, FPSP and 3DSP
21:05:39 <AnMaster> ais523, heh I should probably try to learn prolog
21:05:45 <AnMaster> got a link for any good online resource?
21:05:57 <ais523> AnMaster: I learnt it from paper books originally
21:06:22 <ais523> there probably are some
21:06:26 <ais523> but Prolog is... different
21:06:35 <ais523> and many sources for it start by trying to compare it to something
21:06:44 <AnMaster> ais523, I have seen backtracking done in scheme
21:06:49 <ais523> which I think is a bad way to learn it, but how else could you start?
21:07:04 <AnMaster> and it abused both macros and call/cc
21:07:16 <ais523> abusing call/cc is an obvious way to do backtracking
21:07:42 <AnMaster> In fact I find call/cc abusive for anything, yes I see how it is useful
21:08:09 <AnMaster> and I can write perfectly fine and working scheme programs without either macros or call/cc
21:08:12 -!- Deewiant has quit ("Viivan loppu.").
21:08:37 -!- Deewiant has joined.
21:10:14 <oerjan> backtracking is a monad, and all monads can be implemented with call/cc, i hear
21:10:46 <ais523> oerjan: I had a discussion with a really theoretical computer scientist once
21:11:02 <ais523> I asked whether backtracking was a monad, and he said it couldn't be because that obviously would fail on infinitely large data sets
21:11:09 <ais523> but I was too confused to ask him to elaborate on that
21:11:10 <fizzie> I think SICP has one chapter about their amb-eval thing, which implements Scheme with a "(amb x y z)" special form, which will evaluate to the "correct" value, backtracking whenever it fails (hits (amb) with no choices).
21:12:47 <fizzie> Well, subchapter, anyway. It's there where they start with the metacircular evaluator, then try lazy evaluation with it, then the nondeterministic amb thing, and finally some logic programmingsies.
21:16:57 <oerjan> ais523: maybe he was confused about something like that amb which only takes a finite number of arguments...
21:17:11 <oerjan> but you can obviously get around that with recursion
21:18:57 <oerjan> and backtracking _does_ fail on infinitely large data sets, if by fail you mean "never gets to the end"
21:20:27 <jayCampbell> elsif command == '[' and tape[thread[pointer]] == 0
21:20:43 <ais523> that isn't exactly a question...
21:21:02 <jayCampbell> does the matching ] brace do a test as well?
21:21:09 -!- Deewiant has quit ("Viivan loppu.").
21:21:19 <jayCampbell> brainfuck spec on esowiki says no, but one of the derivatives did
21:21:20 -!- Deewiant has joined.
21:21:30 <ais523> jayCampbell: it doesn't matter normally
21:21:39 <ais523> because either ] jumps back to [, which does the test
21:21:43 <ais523> or ] does the test itself
21:21:53 <ais523> thus specs generally say either
21:22:17 <ais523> one big advantage of testing at both ends is it then doesn't matter which side of the [] you jump back to, but that's an implementation detail that rarely comes up
21:22:31 <ais523> basically, it doesn't matter unless you're implementing, in which case you can choose either
21:22:48 <ais523> implementations in most programming languages test just at the [ because that fits the semantics of while loops
21:23:01 <ais523> but if you're implementing BF in an esolang, that's often slower if you have no while-loop-equivalent
21:23:06 <jayCampbell> so i built a weave interpreter (prefork, individual and shared tapes) that does brainfork runtime threading and pbrain subroutines
21:23:39 <AnMaster> ais523, actually I remember testing once at entry and after that I tested if I should jump back at the end
21:23:48 <AnMaster> and then jumped to the instruction after the matching [
21:24:08 <ais523> AnMaster: there are a huge number of ways to do it, I think
21:24:33 <AnMaster> ais523, in before I just emit a while loop currently
21:24:46 <AnMaster> in the future I will emit for loops for balanced pure loops
21:25:00 <AnMaster> yes it doesn't match pure as in pure functional
21:25:10 <AnMaster> but it was the best word I managed to come up with
21:25:22 <AnMaster> ais523, of course I plan to optimize it even more later on
21:25:38 <AnMaster> but currently I haven't managed to understand exactly how that would be done
21:25:52 <AnMaster> also it will to for when io isn't on iteration counter cell
21:26:20 -!- psygnisfive has quit (Remote closed the connection).
21:29:56 <AnMaster> balanced, noinput, noputput, iter_noinput
21:30:02 <fizzie> fungot's brainfuck turns [ into bytecode "jump if zero" and ] into "jump if nonzero", with jump targets being one past matching pair.
21:30:03 <fungot> fizzie: xpdf really should allow searching with regexps, ' fnord
21:30:43 <AnMaster> bool balanced, noinput, nooutput, iter_noinput;
21:30:43 <AnMaster> balanced = noinput = nooutput = iter_noinput = false;
21:32:05 <ais523> although on an embedded system, you could save 3 bytes of memory by making them bitfields in a struct
21:32:26 <ais523> and it'll be faster that way on most such systems as they have bit-test instructions, they can handle bits faster than entire ints
21:32:32 <ais523> OTOH, most RL processors will prefer ints
21:34:46 <AnMaster> just I need to track them in the function
21:35:11 <AnMaster> bool noinput, nooutput, iter_noinput;
21:35:11 <AnMaster> noinput = nooutput = iter_noinput = true;
21:52:33 -!- ehird has joined.
21:53:06 <ehird> http://www.formauri.es/personal/pgimeno/temp/esoteric/paintfuck/decimal-counter-uncommented.pfk
21:53:50 <pgimeno> I liked the idea of "OCRing"
21:54:24 <ehird> how does it OCR so quickly?
21:54:44 <pgimeno> I found a bit pattern that worked for all numbers
21:54:56 <pgimeno> http://www.formauri.es/personal/pgimeno/temp/esoteric/paintfuck/decimal-counter.pfk
21:55:03 <ehird> haha, that's great
21:55:14 <pgimeno> chained IFs except for distinguishing 0 from blank
21:55:16 <ehird> i really like the logistical constraints paintfuck givse
21:55:21 <ehird> your output IS your memory, it's just such a nice idea
21:55:49 <ais523> someone should make a version of PaintFuck where the source code is stored on the 2D tape, too
21:56:52 <ehird> pgimeno: wht happens when it reaches its own start?
21:56:53 <pgimeno> fixed a repeated comment in the commented version, reload
21:56:55 <ehird> does it just implode?
21:57:02 <jayCampbell> weave.rb reflective via braintwist's X swapper now
21:57:06 <ehird> it'd be infeasable to wait that long ofc :P
21:57:11 <pgimeno> ehird: dunno, try a smaller grid, it's designed for infinite grid
21:59:11 <ehird> it starts counting the wrong digit
21:59:16 <ehird> while making up its own digits :P
21:59:18 <pgimeno> so it works on infinite grid
21:59:45 <pgimeno> yes, it increments by knowing which bits to change, if the number is not the expected it breaks
22:00:01 -!- ehird has left (?).
22:00:04 -!- ehird has joined.
22:02:21 -!- ehird has left (?).
22:02:24 -!- ehird has joined.
22:02:37 -!- ehird has left (?).
22:02:40 -!- ehird has joined.
22:02:43 -!- ehird has left (?).
22:02:46 -!- ehird has joined.
22:02:57 -!- ehird has left (?).
22:06:07 <AnMaster> * oklopol has quit (Connection reset by peer)
22:06:13 <AnMaster> not that you will see it anyway
22:09:27 <ais523> I didn't get a /msg from you
22:09:39 <ais523> oh, you warn me about /msg /before/ you say it?
22:16:17 -!- oerjan has quit ("Good night").
22:24:22 -!- oklopol has joined.
22:25:11 <ais523> because it spams the rest of the channel for no obvious reason
22:25:25 <ais523> if something's the sort of private thing that goes in /msg, why tell everyone else about it?
22:26:14 <AnMaster> and didn't want to open pastebin
22:26:20 <oklopol> why refer to the past just as i join.
22:26:52 <ais523> oklopol: we were discussing why AnMaster warns people they're about to get a /msg before e /msgs them
22:26:52 <AnMaster> ais523, oh also how would you transfer a balanced loop to a polynom?
22:27:03 <ais523> AnMaster: using algebra
22:27:09 <ais523> the balanced loop runs the number of times of the first arg
22:27:21 -!- lostgeek has quit ("leaving").
22:27:25 <ais523> so you take the first arg, and multiply it by all increments inside the loop
22:27:43 <ais523> so [->+<] is tape[0] times tape[1]++ or tape[1]+=tape[0]
22:27:45 <AnMaster> polynoms, isn't that 4 + 2a + 1b^2 + 3c^3 = 0
22:27:46 -!- ehird has joined.
22:28:08 <ais523> so it goes from +1 to +x, effectively
22:28:14 <ais523> with another nested loop, it can be +x^2
22:28:16 <AnMaster> ais523, that require balanced "no-io" loops
22:28:57 <oklopol> he probably warns you so you can say no if you're naked and don't want to see or something, kinda like a doorbell.
22:29:16 -!- Corun has quit ("Leaving").
22:29:32 <ais523> oklopol: /msg doesn't work like that, though, does it?
22:29:32 <AnMaster> oklopol, err, irc is text only
22:29:40 <ais523> more to the point, it's the other way round
22:29:49 <AnMaster> also /msg is just the same as channel messages
22:30:07 <ais523> I suppose that if AnMaster warned me that he was about to send me an ASCII art goatse, a warning would give me time to ignore him
22:30:08 -!- GreaseMonkey has joined.
22:30:12 <ais523> but why would he do that?
22:30:31 <AnMaster> they are both the same on protocol level
22:30:32 <oklopol> AnMaster: as opposed to ais523's
22:30:52 <ais523> AnMaster: correct but not very relevant point, I think oklopol meant
22:30:57 <AnMaster> >> :ais523!n=ais523@eso-std.org PRIVMSG #esoteric :+AnMaster: correct but not very relevant point, I think oklopol meant
22:31:21 <oklopol> what ais523 said i didn't think about, what AnMaster said was a trivial fact i didn't consider worth mentioning
22:32:07 -!- Corun has joined.
22:32:09 <oklopol> oooooooooooooooooooooooooooooooooo
22:32:35 <oklopol> yes i see you're in a goody moody!
22:33:29 <oklopol> actually... really had nothing to do with triviality, it's just what AnMaster said escaped the analogy, making it kinda pointless as what i said was just a joke
22:33:49 <oklopol> while ais523 attacked the analogy, which is relevant even if it's a joke
22:34:29 * AnMaster ponders referring to the future just as oklopol will part
22:34:48 <AnMaster> that is the opposite of talking about the past forcing you to read logs
22:35:00 <oklopol> just as i part or just before it
22:35:20 <oklopol> just as i'm about to leave
22:35:42 <oklopol> "ais523, so wanna talk about this interesting thing?", and ais523 responds, umm, "yes"
22:36:14 <AnMaster> oklopol, yes or maybe about what we will say
22:36:26 <AnMaster> like. "will you mean that a == b"?
22:36:38 <oklopol> well actually you'd have to refer to it, that'd be more complicated
22:36:53 <oklopol> in detail, that's the point
22:37:33 <ais523> oklopol: what's with your typo corrections?
22:37:41 <AnMaster> <ais523> because it spams the rest of the channel for no obvious reason
22:38:10 <ais523> AnMaster: that would somehow connect oklopol around into a loop, though, wouldn't it?
22:38:21 <AnMaster> ais523, well just as an example
22:38:47 <AnMaster> <AnMaster> ais523, why will you not?
22:39:04 <AnMaster> <ais523> because it will spam the rest of the channel for no (currently) obvious reason
22:39:14 <AnMaster> <AnMaster> will be good reason
22:39:20 <AnMaster> ais523, just tried to make it future
22:39:30 <AnMaster> that doesn't work for that example
22:39:37 -!- psygnisfive has joined.
22:39:43 <oklopol> ais523: my typo corrections got tired of having to exist so often.
22:39:49 <oklopol> so they committed suicide.
22:39:55 <ais523> in that case, probably using the present would be more idiomatic even if you're talking about the future
22:40:23 <ais523> "why won't you?" "because it will spam the rest of the channel" "hmm... ok; that's a good reason"
22:40:28 <ais523> but the last there is true present
22:40:33 <GreaseMonkey> why correct when you can type with your eyes ckised?
22:40:50 -!- Corun has quit ("Leaving").
22:41:02 <oklopol> i never look at my fingers
22:41:11 <ais523> why cprrecy wjem ypi cam type with your ues c;psed?
22:41:16 <GreaseMonkey> it's a fun thing to try but not with a lump in your eye >_> <-- did it
22:41:23 <ais523> wow, the result of that actually came out readable
22:41:36 <ais523> I even got 3 words in a row right
22:41:51 <ais523> took me a few seconds to find home row, then I typed it all quite quickly
22:42:19 <GreaseMonkey> enjoy coca cola. but enjot brainfuck even more.
22:42:23 <oklopol> if you use a sensible system, there's no difference whether they're open or not
22:46:25 <AnMaster> ais523, exactly how were you typing?
22:46:37 <ais523> AnMaster: with my eyes shut
22:46:58 <ais523> even using the bumps on f and j to find the home row
22:47:30 <ais523> one of the garbles was because I forgot the bump was on j not h, normally I hover my fingers over f and h because I rarely type ;
22:49:34 <oklopol> i don't make any more mistakes with my eyes closed, i would never click enter before checking i typed it right though
22:50:23 <AnMaster> I know the keyboard well enough
22:54:28 <AnMaster> as soon as I find space, shit or enter
22:55:16 * AnMaster could probably use "das keyboard" if only it had Swedish keyboard layout
22:56:16 <oklopol> "shit" doesn't sound very AnMastery.
22:56:38 <oklopol> i, on the other hand, can find shit pretty well on my keyboard
22:57:24 -!- psygnisfive has quit (Remote closed the connection).
22:58:07 -!- psygnisfive has joined.
22:58:09 <AnMaster> well the keyboard does in cleaning
22:59:34 <oklopol> i recently found a keyboard on teh nets that had the keys in straight columns instead of diagonally randomized
22:59:45 <oklopol> but that was costy, and i have a laptop
22:59:55 <oklopol> but that might be pretty awesome
23:01:59 <MizardX> http://www.vjn.fi/pb/p333662665.txt Paintfuck decimal counter :)
23:03:02 <AnMaster> MizardX, didn't someone else here also make one
23:03:26 <AnMaster> MizardX, why did you want to make a decimal counter?
23:04:10 <MizardX> I saw a few hours ago that someone mentioned it. Thought it could be fun for a first paintfuck program. :)
23:04:59 <fizzie> That reminds me of a telemarketer that called my wife and tried to sell some magazine. When she said "no", the telemarketer said she needs to justify why she didn't want to order it. The implication was that if the reasons aren't good enough, she doesn't get to not order it.
23:05:23 <AnMaster> fizzie, err that wouldn't be legal
23:07:52 -!- psygnisfive has quit (Remote closed the connection).
23:08:14 -!- psygnisfive has joined.
23:08:43 -!- decipher has quit (Read error: 54 (Connection reset by peer)).
23:10:43 <oklopol> fizzie: well what happened, were the reasons good enough?
23:11:30 <oklopol> MizardX: haha that's pretty great
23:12:54 <AnMaster> I change in place so I can't compare tree after
23:13:08 <AnMaster> I could pass a flag if anything was changed
23:14:06 -!- decipher has joined.
23:28:31 <oklopol> MizardX: when the counter overflows, does it output "counter overflow, try increasing screen width", and you've hidden that in the code so that an average human brain cannot find that in teh code?
23:31:08 <oklopol> WHAT, it just spouts random garble!
23:31:09 <MizardX> If the screen width is a multiple of four, the (w/4+1)'th digit would increase the ones, and it would continue counting. If the screen width is not a multiple of four, the result is undefined.
23:34:16 -!- Corun has joined.
23:34:26 <pgimeno> MizardX: great! seems that yours is more homogeneous than mine timing-wise
23:35:52 <pgimeno> which should be no surprise given the nested ifs I use
23:36:05 <ehird> http://www.formauri.es/personal/pgimeno/temp/esoteric/paintfuck/decimal-counter-uncommented.pfk
23:36:06 <ehird> http://www.formauri.es/personal/pgimeno/temp/esoteric/paintfuck/decimal-counter.pfk
23:36:24 <ehird> well pgimeno's digits are more readable
23:37:09 <ehird> pgimeno's seems to be faster
23:37:15 -!- psygnisfive has quit (Remote closed the connection).
23:38:22 -!- psygnisfive has joined.
23:38:46 <pgimeno> it may depend on the interpreter, if a certain kind of instructions are not the same speed
23:39:54 <oklopol> now someone make a library for simplifying equations expressed as drawn digits & operators
23:40:18 <oklopol> well anyway, something sensible ;)
23:40:31 -!- Judofyr has quit.
23:47:18 -!- psygnisfive has quit (Remote closed the connection).
23:47:41 -!- psygnisfive has joined.
23:54:17 -!- jix_ has quit ("...").