00:01:15 -!- nooga has joined.
00:01:18 <nooga> http://3537.pl/programista.html
00:07:57 -!- oerjan has joined.
00:09:27 <nooga> you have to read a sequence of memory states and output the shortest boolfuck program that transforms memory from one state to another
00:27:21 <Sgeo__> SG-1 > Thing due in a week
00:27:32 <Sgeo__> That I would have had a month to work on if my computer was working
00:30:08 -!- SgeoN1 has joined.
00:30:41 <SgeoN1> Alise, ping me before you leave
00:52:50 -!- Portponky has quit (Quit: chicken is nature's potato).
01:10:25 <SgeoN1> Hmm, I think not having a commercial break here would make the episode worse.
01:13:52 <nooga> just out of curiosity, any ideas?
01:14:29 <oerjan> a pyramid made out of giant fries
01:15:03 <oerjan> (going with the potato theme here)
01:15:56 <nooga> but the boolfuck delta between two memory states sounds more interesting
01:16:20 <pikhq> If less delicious.
01:25:56 -!- alise has quit (Ping timeout: 252 seconds).
01:28:21 <nooga> still, this problem sounds interesting
01:33:02 <Ilari> Isn't the general problem of taking two memory states and outputting shortest program to transform them from first to second RE-hard?
01:36:06 <oerjan> well starting from an empty state gives you kolmogorov complexity, which is undecidable
01:36:38 -!- uorygl has quit (Read error: Connection reset by peer).
01:36:55 -!- uorygl has joined.
01:36:58 -!- uorygl has quit (Read error: Connection reset by peer).
01:41:56 -!- uorygl has joined.
01:41:57 <nooga> it's not two memory states to be exact
01:42:43 <nooga> http://3537.pl/programista.html check out the 'przykład' section, there is a sample input and output
01:44:51 <oerjan> um boolfuck has no I/O, so i would assume the input is the initial memory state, and the output is the final one, with some simple encoding.
01:45:24 <oerjan> and that's enough to make it undecidable in general (in fact the input is unnecessary)
01:45:53 <nooga> you get a sequence of memory states
01:46:21 <nooga> and you have to find a program that produces them during it's execution
01:47:06 <nooga> 000,100,110,111 the program is +>
01:47:12 <oerjan> s/nooga> yes/nooga> no/
01:47:45 <nooga> if you'd only the firs and the last state
01:48:15 <oerjan> i thought bf.in and bf.out were I/O for the boolfuck program, sheesh
01:49:40 <nooga> nah, your task is to generate boolfuck program for given input
01:49:49 <oerjan> ok. it's still undecidable in principle since it's undecidable between any pair of consecutive states.
01:50:09 <oerjan> but obviously if the programs are very short, you can solve it
01:50:15 -!- alise has joined.
01:50:53 <alise> <nooga> http://3537.pl/programista.html
01:50:57 <alise> eset -- they make NOD32, yeah?
01:51:14 <alise> and their job offer involves boolfuck?
01:51:18 <alise> sounds like a pretty good place to work
01:52:22 <oerjan> nooga: the tape length is fixed in advance? then it's solvable.
01:53:39 <oerjan> since then so is the halting problem
01:54:46 <alise> nooga: i say go for the job :P
01:54:51 -!- Zuu has quit (Ping timeout: 276 seconds).
01:54:54 <oerjan> assuming there's nothing non-obvious written in that polish
02:01:48 -!- Zuu has joined.
02:01:49 -!- Zuu has quit (Changing host).
02:01:49 -!- Zuu has joined.
02:04:51 <alise> "--and also, whomsoever solves this problem hereby enlists their soul towards our demonic army of gnomes, who do verily check every file. You thought that was a program? Ha ha ha ha ha ha..."
02:19:07 -!- nooga has quit (Ping timeout: 258 seconds).
02:36:26 <alise> hey guys I proved P=NP
02:37:09 <alise> { i = 0; for (sol in possible_solutions) { if correct(sol) return sol; if (i > 10^(10^100)) halt; } }
02:37:17 <alise> (note: algorithm is unusable)
02:37:25 <alise> (note: algorithm does always terminate because the universe will be dead by then)
02:41:39 -!- oerjan has quit (Remote host closed the connection).
02:41:46 -!- oerjan has joined.
02:41:48 <alise> --but nobody will ever know it, ha ha ha
02:42:09 <oerjan> strange network error just as i was typing my comment :(
02:42:19 <alise> what's the bug then smarty :P
02:42:33 <oerjan> i is never incremented
02:42:44 <alise> um that's a feature of the language
02:42:49 <alise> { i = 0; for (sol in possible_solutions) { if correct(sol) return sol; if (i > 10^(10^100)) halt; i++ } }
02:42:53 <alise> amended version for those who don't understand.
02:43:14 <oerjan> as i was saying but got cut off
02:43:29 <oerjan> there's an algorithm guaranteed to work _if_ P=NP
02:43:48 <oerjan> just iterate through all possible P algorithms
02:44:04 <alise> and besides, P=NP is practically worthless -- people who think it isn't are stupid :)
02:44:15 <alise> Since you can always have an O(n) algorithm with a really fucking huge constant.
02:44:19 <pikhq> oerjan: Is the set of possible P algorithms finite?
02:44:33 <alise> and dynamic programming + heuristics make NP problems okay in practice
02:44:37 <alise> pikhq: No, does that matter?
02:44:41 <pikhq> Oh, wait, doesn't matter.
02:44:46 <alise> The naturals are infinite, but looping through them until you find a certain one will always halt.
02:44:49 <oerjan> pikhq: no, but... oh wait
02:44:58 <pikhq> You *will* eventually find something, yes.
02:45:04 <pikhq> As the set is most certainly countable.
02:45:31 <oerjan> hm maybe i remember it wrong, it seems to have an issue if the answer is "no"
02:45:41 <alise> btw I hypothesised about a halting-checker;
02:45:47 <alise> you can do things such as:
02:45:52 <Ilari> Even O(n^6) algo gets inpractical fast (just look at state-of-the-art AKS-based primality tests).
02:46:04 <alise> check statements of the form "forall x in naturals, P(x)" and "exists x in naturals s.t. P(x)"
02:46:14 -!- Gregor has quit (Ping timeout: 252 seconds).
02:46:18 <alise> and also evaluate all convergent infinite sums (without analytic/symbolic methods)
02:46:23 <alise> but you cannot do the same for the reals
02:46:30 <Ilari> There are (countably) inifinite number of problems in P.
02:46:34 <alise> I tried recursively nesting halt-checker calls, but you can't do it
02:47:29 <alise> "Peter Shor points out that if were living in a simulation, then the incompatibility of quantum mechanics with general relativity might simply be a bug, in which case the universe will crash when the first black hole evaporates."
02:47:32 <alise> AIEEEEEEEEEEEEEEEEE
02:48:04 <oerjan> nah the black holes are page faults
02:49:24 <Ilari> Or then, GR is wrong (at least when describing such extreme things as black holes...)
02:49:50 <alise> Ilari: well he said "might"
02:50:06 <alise> maybe string theory exposes the internal object representation of particles :-)
02:50:10 <pikhq> oerjan: Seems to me that page faults being noticable is a bug.
02:50:58 <pikhq> Ilari: Even O(1) can absolutely suck if that constant factor is long.
02:52:31 <Sgeo__> Hm, alise is still here
02:53:45 <alise> yeah. i'm being hideously irresponsible
02:54:04 <pikhq> I'm just impressed you slept last night.
02:57:48 <alise> pikhq: http://nautilus.cs.miyazaki-u.ac.jp/~skata/MagicHaskeller.html
02:57:53 <alise> -- The following will find the recursive form definition of the fibonacci function from its closed-form solution.
02:57:53 <alise> init075 -- The problem is tough, so you should be prepared to resort whatever measure you can take!
02:57:53 <alise> printAny (f -> all (n -> (f :: Int->Int) n == let phi = (1 + sqrt 5)/2 in round ((phi^n - (1-phi)^n) / sqrt 5) ) [0..9])
02:58:09 <alise> (Note of course that the Japanese yen sign is, in all the Windows fuckup glory, being used as a backslash.)
02:58:13 <alise> (Just like in file paths.)
02:58:50 <pikhq> To be perfectly fair to Windows, that's actually a fuckup from the JIS that old version of Windows merely complied with.
02:59:53 <alise> But yeah, pikhq, this thing generates the recursive haskell fibonacci from Binet's formula.
03:00:04 <alise> Admittedly it isn't looking at Binet's formula -- pre-computed instead -- but still!
03:00:48 <pikhq> Japanese Industrial Standard.
03:01:56 -!- Gregor-L has joined.
03:03:58 <alise> Japanese Industrial Shitpile
03:04:42 <pikhq> The JIS standards are a shitpile.
03:16:14 <alise> I'm bored, and I'm going to bed soon. But I'm still bored.
03:17:15 -!- augur has quit (Remote host closed the connection).
03:17:28 -!- augur has joined.
03:17:45 <alise> Would you like to play a game? [anything]
03:17:45 <alise> The only winning move is
03:17:55 <alise> It needs to include a full simulation of Global Thermonuclear War and Tic-Tac-Toe.
03:18:37 <augur> thermonuclear tic-tac-toe?
03:19:00 -!- ws has quit (Quit: ...).
03:20:36 <alise> I've discovered a brilliant hangman strategy.
03:20:45 <alise> Just start "etaoinshrdlu".
03:20:54 <oerjan> augur: i see great potential there
03:21:24 <alise> [[Twenty masked gunmen in Gaza attack and burn to the ground a summer camp for children run by UNRWA for "teaching schoolgirls fitness, dancing, and immorality."]]
03:25:22 <alise> i thought it said "immortality"
03:26:53 -!- Gregor-L has changed nick to Gregor.
03:26:54 <pikhq> If only they could teach immortality.
03:27:09 <pikhq> Hellote again sir.
03:28:18 <alise> i thought it was some awesome religious crazies
03:28:27 <alise> THEY TEACH IMMORTALITY!!! THIS IS UNHOLY!!
03:28:45 <alise> ehird@ehird-desktop:/usr/games$ ./arithmetic
03:28:46 <alise> 6 + 8 = Wow, fuck this.
03:28:46 <alise> Please type a number.
03:28:53 <alise> Some BSD games really suck.
03:29:42 <augur> a better game would be /usr/games/ImpossibleMathProblems
03:30:06 <alise> Do all of the zeroes of the Riemann zeta function lie on the critical line?
03:30:06 <pikhq> /usr/games/Level5ProblemsFromTheArtOfComputerProgramming
03:30:20 <alise> Can the problems in NP be solved by a P algorithm?
03:30:20 <augur> problem one: prove that for all n > 2 and all x, y, z in N, x^n + y^n != z^n
03:30:29 <alise> Do all Collatz sequences eventually reach 1?
03:30:35 <pikhq> augur: That's no longer level 5.
03:30:39 <alise> augur: that's already been proven.
03:30:50 <augur> yes, but its still pretty hard :P
03:30:58 <pikhq> Yes, but it's not level 5!
03:31:05 <augur> construct an ELEGANt proof of that.
03:31:11 <alise> What are the level 5 problems then?
03:31:14 <alise> augur: Wiles' proof is elegant.
03:31:30 <pikhq> alise: Problems with unknown solutions, IIRC.
03:31:36 <augur> im not sure that mathematicians agree.
03:31:59 <pikhq> More elegant than everything else we've got.
03:32:11 <pikhq> Except for that one the margin is too small to contain.
03:32:44 <alise> augur: I'm relatively sure you're wrong.
03:32:58 <alise> "Such-and-such's proof of X is ugly because it's complicated" is basically what laymen think.
03:33:03 <augur> his proof certainly isnt marginalia, thats for sure
03:33:12 <alise> Yes - that's because Fermat was full of shit.
03:33:33 <alise> The problem is Hard. The countless numbers of false solutions and the fact that only advanced mathematics solved it show with extremely high probability that Fermat was simply wrong about having a proof.
03:34:26 <Ilari_antrcomp> What was length of the proof? 350 pages or so? That can't be elegant.
03:34:37 <pikhq> Pity he didn't have a larger margin.
03:34:44 <alise> The Wiles paper is over 100 pages long and often uses the peculiar symbols and notations of group theory, algebraic geometry, commutative algebra, and Galois theory.
03:34:46 <alise> Over 100 pages isn't too bad.
03:34:57 <alise> Remember that it turns out that Fermat's Last Theorem is pretty damn advanced stuff!
03:35:07 <alise> Not everything can have a trivial proof. That doesn't mean the complicated proofs aren't elegant.
03:36:21 <alise> http://math.stanford.edu/~lekheng/flt/wiles.pdf ;; the proof as it was published in Annals of Mathematics
03:36:27 <Ilari_antrcomp> Reminds of excercise problem of proving that every undirected graph can be converted to directed graph such that on every vertex, indegree and outdegree only differ by at most 1...
03:36:33 <alise> http://users.tpg.com.au/nanahcub/flt.pdf ;; one with searchable text (much smaller; hundreds of kilobytes instead of 10mb)
03:37:35 <alise> Of course, I don't understand it; I doubt many people do.
03:37:36 <Ilari_antrcomp> There's at least elegant way of proving that and unelegant way.
03:37:41 <alise> But I don't look at it and see an ugly thing.
03:37:49 <alise> I see a very complicated, complex thing, but not a gnarly thing.
03:39:15 <alise> Besides, that article isn't even a proof of FLT.
03:39:37 <alise> It's a proof of an entirely different theorem; FLT just so happens to follow from it and countless other lemmas posed before.
03:39:43 <Ilari_antrcomp> Elegant proofs tend to take huge leaps that are simple, yet unobivious.
03:39:54 <alise> The actual proof of FLT would just be... <huge list of lemmas & theorems including the one Wiles proved> "Q.E.D."
03:41:10 <Ilari_antrcomp> Like leaping from that direction problem to eulerian circuits.
03:41:27 <comex> http://www.x11r5.com/
03:42:02 * comex recently read a semishitty science fiction book about FLT
03:42:21 <alise> what on earth is x11r5.com :)
03:42:38 <alise> Why's it have that name?
03:42:48 <alise> fungot: you're more coherent than x11r5.
03:42:48 <fungot> alise: is the language/ library dichotomy, i know; it's an occupational hazard for all of them
03:42:54 <fungot> Available: agora alice c64 ct darwin discworld europarl ff7 fisher ic irc* jargon lovecraft nethack pa speeches ss wp youtube
03:42:58 <alise> fungot: Wax eloquent.
03:42:59 <fungot> alise: my network outage took a lot of native ppc code compilers for scheme or any other swear wordswear. what more could one ask for? i'm trying to
03:43:05 <Sgeo__> Because it uses the X11 server to .. do something
03:43:11 <fungot> alise: which would mean no integer arrays larger than 64k bytes, or truncate the key? evil grin which would have told me, what?"
03:43:15 <Sgeo__> I'm not creative enough to come up with a good joke
03:43:57 <Sgeo__> It runs some code in an xterm, takes a screenshot, and uploads it
03:44:29 <fungot> Selected style: agora (a large selection of Agora rules, both current and historical)
03:44:39 <comex> fungot: prove Fermat's Last Theorem
03:44:39 <fungot> comex: ( i) satisfy the draw within a time limit, e ceases to hold the delegated player;
03:45:28 <augur> alise: ahh but what if fermat's proof was real :o
03:45:59 <fungot> Selected style: nethack (NetHack 3.4.3 data.base, rumors.tru, rumors.fal)
03:46:06 <comex> fungot: prove Fermat's Last Theorem
03:46:06 <fungot> comex: if you try to zap it!" but the sword.
03:46:14 <fungot> Selected style: darwin (Books by Charles Darwin -- you know, that evilution guy)
03:46:20 <comex> fungot: prove Fermat's Last Theorem
03:46:20 <alise> fungot: i bet darwin could prove FLT with smilies
03:46:21 <augur> alise: oh pshaw you dont know
03:46:21 <fungot> comex: my chief object is to see a flora written by a man who intends keeping pointers naturally tries to get/ subject as clear as daylight. old flourens " ( examen du livre de m. darwin une critique dont je fnord trouve que des debris dans un journal fnord.,/ outer edge :)/ reef.
03:46:22 <fungot> alise: origin :) species,' and arranged for/ publication :) one volume for 1867-8.) i particularly admired tyndall's little speech " professor tyndall was president :)/ royal society, with notes on.
03:46:33 <alise> On / Origin :) Species
03:47:04 <alise> words deemed too rare to place in the file
03:47:05 <comex> what exactly is the source of that :p
03:47:07 <alise> :) and / are encoding errors
03:47:18 <fungot> Selected style: alice (Books by Lewis Carroll)
03:47:20 <fungot> alise: ' i'm not a bird!' and the waiters set a leg of mutton, and began fnord them into colours.
03:47:23 <fungot> Selected style: youtube (Some YouTube comments)
03:47:28 -!- coppro has quit (Quit: I am leaving. You are about to explode.).
03:47:36 <comex> fungot: I would not have thought of using YouTube comments.
03:47:37 <fungot> comex: 15 seconds. what the hell
03:47:47 <fungot> alise: why internet is like wtf
03:47:49 <comex> fungot: took you less than that to respond, eh?
03:47:49 <fungot> comex: whatever, i've told you where: they do their homework. seriously folks, do your own) so it wont have the same
03:47:55 <alise> `addquote <fungot> alise: why internet is like wtf
03:47:55 <fungot> alise: avril roxs your soxs video
03:47:55 <fungot> comex: well, and the aircraft had no passengers... that guy is fantastic. there were probably 3 people died
03:48:06 <comex> this is the best source.
03:48:08 <HackEgo> 163|<fungot> alise: why internet is like wtf
03:48:18 <alise> comex: it's quite a bit verbatim iirc
03:48:29 <comex> fungot: the aircraft? where?
03:48:29 <fungot> comex: you obviously can't be bothered to read the description! it's kinda scary at first but it was landing at a low approach of a bitch.
03:48:31 <alise> asiekierka assembled it by manually copying/pasting youtube comments (he isn't a good enough programmer to write a scraper)
03:52:19 <Mathnerd314> hmm... did anyone mention how scarily close this game is to a Turing machine: http://jayisgames.com/games/manufactoria/
03:52:36 <alise> It is a turing machine, or at least TC.
03:52:37 <alise> Has unbounded memory
03:53:37 <alise> Not long til I have to be up in 5 hours.
03:55:49 <Mathnerd314> I must admit that I sometimes indulge, however
04:02:19 -!- pikhq_ has joined.
04:04:08 -!- Mathnerd314 has quit (Ping timeout: 240 seconds).
04:04:32 -!- pikhq has quit (Ping timeout: 276 seconds).
04:07:36 <Sgeo__> alise, keep working on improving things
04:07:40 <fungot> Selected style: irc (IRC logs of freenode/#esoteric, freenode/#scheme and ircnet/#douglasadams)
04:07:48 <alise> oerjan: HEY i didn't ask YOU
04:07:53 <alise> and i leave unsatisfied!
04:07:55 -!- pikhq_ has changed nick to pikhq.
04:07:59 -!- alise has quit (Quit: Leaving).
04:15:35 <augur> you know what i need?
04:18:49 -!- lifthrasiir has quit (Ping timeout: 245 seconds).
04:32:06 -!- Oranjer has left (?).
05:01:59 -!- elliottcable has changed nick to ec.
05:02:47 -!- ec has changed nick to \aaa.
05:02:57 -!- \aaa has changed nick to \\-\\.
05:03:45 -!- \\-\\ has changed nick to ec.
05:06:42 -!- Oranjer has joined.
05:43:26 -!- coppro has joined.
06:14:21 -!- oerjan has quit (Quit: Good night).
06:18:28 -!- Oranjer has left (?).
06:32:43 -!- FireFly has joined.
06:32:50 -!- Gregor has quit (Ping timeout: 252 seconds).
06:38:12 <ec> NEENER NEENER
06:38:25 -!- Gregor has joined.
06:44:33 -!- ec has changed nick to metapointer.
06:57:02 -!- Gregor has quit (Ping timeout: 252 seconds).
06:58:54 -!- lifthrasiir has joined.
06:59:28 -!- Gregor has joined.
07:01:36 -!- tombom has joined.
07:01:56 -!- metapointer has changed nick to ec.
07:08:49 -!- lifthrasiir has quit (Ping timeout: 245 seconds).
07:09:27 -!- kar8nga has joined.
07:34:53 -!- lifthrasiir has joined.
07:49:00 -!- FireFly has quit (Quit: swatted to death).
07:51:51 -!- tombom has quit (Quit: Leaving).
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
09:16:15 -!- gm|lap has joined.
10:06:58 -!- Gracenotes has quit (Remote host closed the connection).
10:16:00 -!- Gracenotes has joined.
11:11:49 -!- sebbu2 has changed nick to sebbu.
11:23:39 -!- Gracenotes has quit (Read error: Connection reset by peer).
11:29:42 -!- sdorand has joined.
11:52:00 -!- gm|lap has quit (Quit: ilua).
11:58:55 -!- kar8nga has quit (Remote host closed the connection).
12:07:36 -!- ws has joined.
12:12:48 -!- coppro has quit (Ping timeout: 265 seconds).
12:24:52 -!- MizardX has joined.
12:25:42 -!- Gracenotes has joined.
12:44:43 -!- Mathnerd314 has joined.
13:01:00 -!- FireFly has joined.
13:07:54 -!- Sgeo__ has quit (Ping timeout: 265 seconds).
13:08:11 -!- kar8nga has joined.
13:08:35 -!- Sgeo__ has joined.
13:14:51 -!- Phantom has joined.
13:15:13 -!- Phantom has changed nick to Guest12499.
13:16:13 -!- Guest12499 has changed nick to Phantom_Hoover.
13:16:38 -!- FireFly has quit (*.net *.split).
13:16:38 -!- lifthrasiir has quit (*.net *.split).
13:16:38 -!- jcp has quit (*.net *.split).
13:16:38 -!- Quadrescence has quit (*.net *.split).
13:16:39 -!- ec has quit (*.net *.split).
13:18:37 -!- FireFly has joined.
13:18:37 -!- lifthrasiir has joined.
13:18:37 -!- jcp has joined.
13:18:37 -!- Quadrescence has joined.
13:18:37 -!- ec has joined.
13:42:09 -!- Phantom_Hoover has quit (Ping timeout: 245 seconds).
13:54:41 -!- MigoMipo has joined.
14:06:03 -!- sebbu2 has joined.
14:07:14 -!- kar8nga has quit (Remote host closed the connection).
14:09:02 -!- sebbu has quit (Ping timeout: 260 seconds).
14:09:02 -!- sebbu2 has changed nick to sebbu.
14:35:47 -!- ws has quit (Quit: take a nap).
15:05:26 -!- Gregor has quit (Ping timeout: 252 seconds).
15:07:09 -!- augur has quit (Ping timeout: 245 seconds).
15:07:21 -!- Phantom has joined.
15:07:49 -!- Phantom has changed nick to Guest93365.
15:08:53 -!- Guest93365 has quit (Client Quit).
15:25:26 -!- sdorand_ has joined.
15:28:04 -!- sdorand has quit (Ping timeout: 265 seconds).
15:34:22 -!- Gregor-L has joined.
15:41:20 -!- Slereah has quit (Ping timeout: 276 seconds).
15:45:32 -!- Slereah has joined.
15:53:02 -!- Slereah has quit (Ping timeout: 276 seconds).
15:53:18 -!- Gregor-L has changed nick to Gregor.
15:56:51 -!- cheater2 has quit (Ping timeout: 260 seconds).
15:56:51 -!- cheater3 has joined.
16:01:45 -!- Slereah has joined.
16:04:48 -!- oerjan has joined.
16:06:31 -!- BeholdMyGlory has joined.
16:29:02 -!- cheater3 has quit (Ping timeout: 260 seconds).
16:33:00 -!- Zuu has quit (Ping timeout: 276 seconds).
16:33:22 -!- cheater2 has joined.
16:37:48 -!- Zuu has joined.
16:37:49 -!- Zuu has quit (Changing host).
16:37:49 -!- Zuu has joined.
16:46:31 -!- aschueler has joined.
16:51:48 -!- Phantom_Hoover has joined.
16:52:26 * Phantom_Hoover wants to create a Lisp dialect where every instance of "s" is replaced with "th"
16:53:31 <oerjan> *cough* http://esoteric.voxelperfect.net/wiki/LITHP
16:54:56 <oerjan> great nerds think alike
16:55:20 -!- Mathnerd314_ has joined.
16:57:03 -!- Mathnerd314 has quit (Ping timeout: 260 seconds).
16:57:38 -!- Mathnerd314_ has changed nick to Mathnerd314.
17:00:28 <Ilari> I see figuring out Skyroads level format has been discussed here before...
17:05:17 <Phantom_Hoover> Why in the name of goat did we make the wiki public domain?
17:07:46 -!- fizzie has quit (Ping timeout: 260 seconds).
17:08:17 <AnMaster> hm where is ais when you need him
17:09:11 <AnMaster> Phantom_Hoover, isn't the wiki GFDL or CC-by-sa?
17:09:49 * Zuu gives Phantom_Hoover cookies :)
17:09:57 <Zuu> public domain for the win
17:10:30 * Zuu has no clue what people are on about, Zuu just arrived
17:11:07 <Phantom_Hoover> I fact, since it's PD it could be switched with little fuss.
17:11:54 -!- oerjan has quit (Quit: Later).
17:13:25 -!- fizzie has joined.
17:14:04 * AnMaster watches a gtkwave window trying to figure out what is wrong
17:14:42 <AnMaster> anyway, I still need ais, for a VHDL question
17:16:58 <AnMaster> also fun, ghdl seems to accept åäöÄÖ in comments in VHDL. But for Å it complains about invalid char
17:17:29 <AnMaster> I guess UTF-8 åäöÄÖ simply doesn't hit problematic byte values for whatever encoding it uses.
17:17:55 <Zuu> Å is capital å
17:18:03 <Zuu> they should be in the same code tables
17:18:15 <AnMaster> Zuu, I speak Swedish after all. And the file was saved in UTF-8
17:18:24 <AnMaster> presumably, it doesn't use UTF-8 though
17:18:25 <Zuu> meaning that if one is problematic the other should be aswell
17:18:37 <AnMaster> Zuu, well that was not the case
17:18:49 <Zuu> because the software is bugged
17:19:08 <AnMaster> Zuu, well rather, the software in question use some other encoding than UTF-8 when reading the file
17:19:20 <AnMaster> and since the editor saved the file in UTF-8
17:19:35 <AnMaster> presumably Å hits a bad code point while å does not
17:19:39 <Zuu> i just explained to you that even if it does, that wouldnt be the problem
17:19:53 <AnMaster> Zuu, well I maintain that it is logically the problem
17:20:46 <AnMaster> so assuming it treated it as some single-byte encoding... hm
17:21:24 <Zuu> in utf its invalid
17:21:34 <AnMaster> okay so my system is fucked up...
17:21:34 <Zuu> 'å' in latin1
17:21:46 <Zuu> also invalid in utf
17:23:04 <AnMaster> Zuu, on the other hand, what is c3?
17:23:38 <Zuu> i would say yes
17:24:07 <AnMaster> so that happens to be the multibyte codepoint of å then in utf8 presumably
17:25:36 <AnMaster> so... I really need ais now :/
17:25:50 <Zuu> what is this ais?
17:26:04 * Zuu wants icecream
17:26:18 -!- sebbu has quit (Ping timeout: 276 seconds).
17:29:35 <AnMaster> and I really need his knowledge about something (VHDL to be specific)
17:30:17 <Zuu> Not really, i think it has something to do with a storage format for 3d material, no?
17:30:30 <AnMaster> it is a hardware description language
17:30:38 <AnMaster> used to program FPGAs and such
17:30:39 <Zuu> that would have been my second gyess :)
17:31:17 <Zuu> I've read a bit about it
17:31:37 <AnMaster> that was quick: from not having a clue to reading a bit about it ;P
17:32:01 <AnMaster> basically I need this in a port map: foo_vector(32 downto 0) => bar_vector(0 to 32). That is reverse the vector for one component instance (but not for the other one) Which is annoying since that code does not compile. And with 32 signals in that vector, doing manual mapping per signal would be rather annoying.
17:32:14 <Zuu> its a matter of attaching these acronyms to stuff in my grain
17:32:36 <Zuu> knowing the name of somthing is very very different from knowing what something is about
17:33:33 * Zuu knows lots of stuff he doesnt remember the name of
17:34:03 <AnMaster> there is also verilog, another HDL
17:34:14 <AnMaster> so how do you know it wasn't that which you read something about? ;P
17:34:32 <Zuu> Because i read about both
17:34:41 <Zuu> and two more
17:35:50 <AnMaster> okay wtf at the file menu entries in gtkwave...
17:36:20 <AnMaster> I have absolutely no clue what the first one is
17:36:42 <Zuu> probably reload?
17:36:53 <AnMaster> unless it is meant like "read (save file)", but then what the heck does "open" do
17:41:33 -!- ws has joined.
17:52:02 -!- nooga has joined.
17:54:08 <nooga> how to check if ray hits pixel? the ray is given by 2d vector pair (o,d) where o is origin and d is a normalised direction adn pixel is given by 2d vector p
17:55:01 <nooga> i can't figure that out since pixels' coordinates are from Z^2 and vectors are in R^2
17:55:31 -!- tombom has joined.
17:55:35 <AnMaster> nooga, find out if pixel is in the path of the ray
17:55:54 <AnMaster> good point about the Z^2 vs. R^2
17:56:34 <AnMaster> nooga, do the check with an epsilon? Draw the line on a buffer and check if the pixel in question is black (or whatever colour)
17:57:19 <nooga> the second method sounds better
17:58:58 <AnMaster> nooga, the second one sounds like a bad hack
17:59:28 <Zuu> pixels have boundaries, so what you really want is to know the size of the pixel
18:00:00 <nooga> yeah but i've already got buffer together with tested pixels on it
18:00:04 <Zuu> then check if the ray intersects any of the lines that make up the pixel
18:00:09 <AnMaster> so how do you do ray colliding with box?
18:00:20 <Zuu> that's how :)
18:00:26 -!- aschueler has quit (Ping timeout: 276 seconds).
18:00:34 <nooga> and in the case with epsilon, i'd need to find good epsilon... i'm too lazy
18:02:39 <nooga> i could collide with a small circle instead of square
18:04:18 <AnMaster> but what is wrong with a square
18:04:32 <AnMaster> you could in some cases optimise it to only check two or even one side
18:04:50 <AnMaster> like, straight up/down/left/right: only check nearest side
18:04:57 <AnMaster> otherwise only check two nearest ones
18:05:02 <AnMaster> if it is speed that you are worried about
18:06:08 <AnMaster> and if you need to check many pixels against a single ray that would be a win
18:06:27 <AnMaster> since the ray would hit the same one or two nearest side(s) for all pixels
18:06:45 <AnMaster> (unless you bounce, then you need to recalculate it for the new bounced ray)
18:08:54 <AnMaster> well, I have no idea what you use your rays for
18:09:02 <nooga> i'm not raytracing
18:09:19 <nooga> i'm making a program that will be able to recognize shapes
18:09:31 <AnMaster> then I fail to see what you need rays for
18:10:16 <Phantom_Hoover> I mean, are you trying to make it recognise them from a photo, or what?
18:10:42 <nooga> it goes like this: i got a shape, i find it's contour
18:11:33 <nooga> and then i fire rays from the centre, check intersections with the contour
18:12:43 <nooga> and then i've got an array of distances from the centre, then I treat it with FFT
18:13:05 <nooga> and the picture is just a monochromatic bitmap
18:13:40 <AnMaster> nooga, why do you treat it with FFT?
18:13:59 <nooga> to get something that i will be able to compare with another results
18:17:38 <nooga> because comparing arrays of raw numbers is not too accurate
18:18:16 <nooga> so that i need some determinant
18:18:37 -!- nooga has quit (Read error: Connection reset by peer).
18:20:45 -!- kar8nga has joined.
18:22:25 -!- sebbu has joined.
18:29:14 -!- cheater2 has quit (Read error: Connection reset by peer).
18:31:14 -!- cheater2 has joined.
18:56:47 -!- kar8nga has quit (Remote host closed the connection).
19:09:36 <AnMaster> Phantom_Hoover, write hashlife in a HDL of your choice
19:09:50 <AnMaster> also, a GOL processor would be awesome
19:16:16 <Phantom_Hoover> A processor in Life or one that runs it on a hardware level?
19:16:35 <Phantom_Hoover> Also Hashlife uses fancy data structures and pointers and such.
19:17:25 <AnMaster> Phantom_Hoover, also sure, but it could still be done in hardware, after all, hashlife runs on advanced hardware
19:17:35 <AnMaster> of course that doesn't mean it would be easy
19:20:02 <AnMaster> Phantom_Hoover, sure, but that will give you something to do
19:20:09 <AnMaster> it will surely last for a few days
19:20:35 <AnMaster> Phantom_Hoover, well... you didn't ask for something pointfull ;P
19:20:42 <AnMaster> (yes I know that isn't a real word)
19:20:54 <AnMaster> Phantom_Hoover, also there is simulation only
19:21:10 <AnMaster> Phantom_Hoover, okay what about a GOL processor at silicon level. I suggest an 20 nm process
19:22:12 <AnMaster> Phantom_Hoover, a normal 64-bit machine would be limited to a fixed number of cells too
19:22:29 <AnMaster> Phantom_Hoover, of course you will have to pick some upper limit when doing anything in hardware
19:23:01 <Phantom_Hoover> But the most obvious way to do it would involve making a component for each cell.
19:23:04 <AnMaster> Phantom_Hoover, after all, I plan a "mostly synthesisable" befunge93 processor as a summer project
19:23:19 <AnMaster> Phantom_Hoover, yeah nice, concurrent life cpu
19:23:27 <AnMaster> calculating each generation in O(1)
19:23:42 <AnMaster> Phantom_Hoover, idea: make it networked, so each side of the die can hook up to other copies
19:23:59 <AnMaster> by just connecting it to more units at the right connectors
19:24:18 <Phantom_Hoover> So... you could have a large board, with a display unit, which could be linked.
19:24:43 <AnMaster> Phantom_Hoover, since you won't have one pin per cell probably, you would need to have some fast connection between the units
19:24:58 <AnMaster> if it ran at a faster speed than the simulation it would be no issue
19:25:21 <Phantom_Hoover> You can just pass an appropriate string of bits for each side.
19:26:07 <AnMaster> Phantom_Hoover, and yeah you should hook it up to some array of display controllers and drive a huge high DPI OLED or whatever
19:26:14 <AnMaster> just don't do TFT, do something more exotric
19:26:25 <AnMaster> such as oled, plasma, quantum dots
19:27:10 <Phantom_Hoover> Well, with a sufficiently large number of cells, it would pwn even Hashlife for the patterns it could hold.
19:29:00 <AnMaster> how do you write hexdecimal values in VHDL?
19:29:19 <AnMaster> Phantom_Hoover, make it async. SOMEHOW
19:29:38 <AnMaster> Phantom_Hoover, hash life sucks at highly chaotic patterns
19:29:52 <AnMaster> Phantom_Hoover, so this would beat hashlife at those
19:30:09 <AnMaster> Phantom_Hoover, there are some examples in golly for which hashlife has problems not just at the start iirc
19:32:00 <AnMaster> Phantom_Hoover, see HashLife/hashlife-oddity1.mc iirc
19:34:21 <Phantom_Hoover> You'd need billions of cells to see anything interesting in that.
19:34:50 <AnMaster> Phantom_Hoover, sure. But why not build a few GB of SRAM + some logic (which is basically what this would be)
19:35:05 <AnMaster> remember you only need one bit per cells
19:35:18 <AnMaster> so a few GB would be 8 times as many cells
19:35:26 <Phantom_Hoover> If you make it "cells outside of bounds are dead", you end up with blocks everwhere.
19:35:42 <AnMaster> Phantom_Hoover, also aren't there wrapping variants of life?
19:36:08 <AnMaster> Phantom_Hoover, if you built it like an old cray machine (that is, curved) this would be easy
19:36:30 <Phantom_Hoover> You can have Life on sensible things like tori, Klein bottles and the projective plane.
19:37:53 <Zuu> And why would you say that you cant have life on spheres?
19:38:12 <Zuu> its just a matter of wrapping a square plane onto the sphere
19:38:47 <AnMaster> Phantom_Hoover, at the poles or what?
19:39:38 <Zuu> Phantom_Hoover: i can easily wrap a checkered square sheet onto a sphere with no two same colored checkers adjacent to each other
19:40:42 <Zuu> .. so that pretty much proves the possibility of having life on a sphere
19:48:15 * AnMaster tries to work out how to convert an x,y coordinate pair to a linear address
19:48:40 <AnMaster> I suppose that using some power of two for one of the sides will be better
19:48:49 <AnMaster> and just ignoring the "spurious" memory
19:51:50 <Zuu> using a multiplication macro?
19:52:01 -!- hiato has joined.
19:52:24 <AnMaster> Zuu, I'm trying to find something that would in theory be possible to synthesise
19:53:17 <Zuu> static multiplication should certainly be possible using an FPGA
19:53:28 <Zuu> so do that
19:53:48 <AnMaster> trying to think of a good way to do it, I'm no VHDL expert (yet!)
19:54:01 <Zuu> addr = x * 25 + y
19:54:40 <AnMaster> except that is nothing like valid VHDL
19:54:48 <Zuu> i dont know valid vhdl
19:54:49 <AnMaster> but sure, to_integer() and some other stuff
19:55:00 <Zuu> im just giving you the general idea :)
19:55:12 <AnMaster> it is the VHDL specific things...
19:56:52 <AnMaster> Zuu, src/fungespace.vhdl:35:31: no function declarations for operator "*"
19:57:07 <Zuu> i believe i told you to use a macro :)
19:57:30 <AnMaster> I used it as an operator anyway
19:57:54 <AnMaster> surely there should be some sort of standard function for it already
19:59:21 <Zuu> I did tell you that i read about it :P
20:01:24 <AnMaster> so something is kind of broken
20:03:44 <AnMaster> okay got something working, but I suspect it isn't possible to synthesise
20:03:53 <AnMaster> well, that Isn't the primary issue atm
20:04:45 <Zuu> Go with microsontrollers, more fun :P
20:04:58 <AnMaster> No. I programmed PIC12F629 once
20:05:10 <AnMaster> I doubt I could do befunge at all in that
20:05:47 <Zuu> I dont know what befunge is, but im quite certain that that pic can calculate anything you throw at it (with enough memory)
20:06:31 <AnMaster> and yeah a PIC doesn't have enough memory
20:06:42 <AnMaster> at least not the ones I worked with
20:06:51 <Zuu> just add extra memory :P
20:07:01 <Zuu> me looks up that befunge
20:07:24 <AnMaster> Zuu, I would say it is one of the most well known esolangs, third place after brainfuck and intercal
20:07:32 <Zuu> Oh, i've seen that language before
20:07:50 * Zuu is not very good with names
20:07:51 <AnMaster> there is befunge93 (what I'm doing in VHDL) and befunge98 (unfeasible for me to do in VHDL currently at least)
20:08:39 <AnMaster> so, now on to the stack. This will be tricky
20:08:49 <AnMaster> I need to keep some internal top of stack signal
20:09:41 <Zuu> well, im no master at fpgas, but considereing how they are intended to work, my guess is that you would practically have to program the fpga to act like a cpu, which itself should be quite a challenge
20:10:05 <AnMaster> for befunge93 it would come close
20:10:08 <Zuu> for any turing complete language
20:10:18 <AnMaster> Zuu, befunge93 is not turing complete
20:10:32 <Zuu> me is dissapointed now :/
20:10:36 <AnMaster> befunge93 has limited fungespace size
20:10:43 <AnMaster> plus you can't reach deep into the stack
20:10:57 <Deewiant> Zuu: Remember, the consensus here is that C isn't Turing complete :-)
20:11:11 <Zuu> well, when i say turing complete i really mean LBA (ofcource)
20:11:15 <AnMaster> Deewiant, yes but there is bignum befunge98, thus it is TC
20:11:35 <AnMaster> my efunge (coded in erlang) uses bignums
20:11:37 <Zuu> Deewiant: the language is, the hardware it runs on just restricts this :)
20:11:50 <Deewiant> Zuu: No, the language isn't, since it requires fixed-size pointers
20:11:57 <AnMaster> Zuu, C suffers from the sizeof() issues
20:12:06 <AnMaster> sizeof(void*) has to be finite
20:12:13 <Zuu> that doesnt make it nont-turing complete
20:12:23 <Zuu> it certainly does not
20:12:40 <AnMaster> Zuu, any given C will be non-TC
20:12:54 <Zuu> you dont seem to understand what turing complete means then
20:13:07 <AnMaster> if sizeof(void*) is 8, then it is CHAR_BITS * 8 that is the limit of the address space
20:13:15 <AnMaster> if it is 16, well then it is CHAR_BITS * 16
20:13:37 <Zuu> its just a matter of encoding of address space
20:13:53 <AnMaster> what on earth do you mean by that
20:14:06 <Zuu> using more bytes to represent an address
20:14:07 <AnMaster> you can't access anything that can't be reached with a void*
20:14:18 <AnMaster> Zuu, sure but then you change the void* size
20:14:22 <Zuu> ofcource you can
20:14:24 <AnMaster> Zuu, but it must still be finite
20:14:37 <Zuu> thats the restriction the hardware sets, not the language
20:14:38 <AnMaster> Zuu, the C spec forbids accessing anything outside your pointer size
20:14:55 <Zuu> that again is the hardware restriction
20:15:04 <AnMaster> Zuu, it is written in the C *spec* though
20:15:11 <pikhq> Zuu: All data must have a valid pointer in C.
20:15:13 <AnMaster> which makes it a spec restriction
20:15:22 <Zuu> consider using the disk to store your data
20:15:28 <pikhq> As such, all things must have a valid, unique void* to them.
20:15:28 <Zuu> again finite space
20:15:39 <Zuu> finite space will _always_ be your issue
20:15:44 <AnMaster> Zuu, again finite due to seek offset having to be finite
20:15:46 <Zuu> at least as far as we know today :)
20:15:56 <pikhq> And what's more, void* must be a size a multiple of the size of a char.
20:16:04 <pikhq> And the maximum value of a char must be storable in a char.
20:16:10 <pikhq> Thus, a char must be of finite size.
20:16:11 <Zuu> so in essence, C can certainly model a turing machine
20:16:18 <pikhq> Thus, *C memory is guaranteed to be finite*.
20:16:27 <AnMaster> Zuu, a turing machine yes. But not an universal one
20:16:52 <pikhq> Zuu: Yes, attaching an infinite tape to C can model a universal Turing machine. However, this is true for many, *many* a finite state machine.
20:17:08 <Zuu> any explanation fo C not being turing complete is a flawed explanation
20:17:18 <AnMaster> pikhq, you can't attach an infinite tape to C though?
20:17:30 <AnMaster> Zuu, is that supposed to make sense even...
20:17:37 <Zuu> pikhq: that wouldnt be a finite state machine then
20:17:39 <pikhq> AnMaster: Sure you can. Not all files are indexable.
20:17:51 <pikhq> Zuu: It's a finite state machine BECAUSE IT HAS FINITE STATE.
20:17:51 <AnMaster> Zuu, it sounds like a religious fanatics kind of point of view.
20:17:58 <AnMaster> saying that "<Zuu> any explanation fo C not being turing complete is a flawed explanation"
20:18:08 <Zuu> pikhq: then it coudlnt be turing complete
20:18:22 <pikhq> Zuu: AND C HAS FINITE FUCKING STATE.
20:18:24 <Zuu> either way you tuirn it you will make it false
20:18:30 <pikhq> Most finite state machines, *when given infinite state to work with*, are magically Turing-complete.
20:18:33 <Zuu> pikhq: no the hardware has
20:18:42 <Zuu> C is a language
20:18:49 <pikhq> Zuu: No, *C is guaranteed by the spec to have finite state*.
20:19:02 <pikhq> It does not specifiy how large that state is, but it *must be finite*.
20:19:21 <Zuu> pikhq: because it is pretty much guaranteed that hardware have finite state ;)
20:19:28 <pikhq> *And thus C describes a class of finite-state machine*.
20:19:43 <pikhq> Zuu: C ITSELF FREAKING DECLARES THAT REGARDLESS OF THE HARDWARE THERE IS FINITE STATE.
20:19:45 <Zuu> so really, any language you can make up cam be said to have finite state in some spec.
20:19:54 <pikhq> EVEN RUNNING ON AN ACTUAL UTM, IT IS DECLARED TO HAVE FINITE STATE.
20:20:00 <AnMaster> Zuu, the problem is not that the hardware is finite (of course it is). The issue is that the spec enforces any implementation to have finite state
20:20:15 <Zuu> AnMaster: and that is very much beside the point
20:20:15 <AnMaster> it is not a valid C implementation if you have infinite state
20:20:25 <AnMaster> Zuu, no it is _exactly_ the point here
20:20:26 <pikhq> Zuu: No, that IS THE POINT.
20:20:36 <Zuu> well, then you have argued for nothing
20:20:39 <pikhq> The POINT is that C is guaranteed to have finite state *by the C standard*.
20:21:01 <Zuu> arguing that D is not TC under the premide it is not TC is idiotic
20:21:21 <Zuu> Argh at spelling
20:21:37 <pikhq> Zuu: Arguing that C is not TC under the premise that *the language is declared in such a way that it is not TC* is not merely idiotic, it's the only real way to go about it.
20:21:53 <pikhq> *Your* premise is "Well, C is declared to have finite state, *but* it's TC."
20:22:11 <Zuu> No i msaying that the hardware is the limitation, shich i said right from the start
20:22:11 <pikhq> That is to say, your premise is about on par with "Well, 1+1 = 2, but 1+1 = fish."
20:22:25 <Zuu> Which in turn is the reason C can be guaranteed to have finite state
20:22:30 <pikhq> Zuu: Irrelevant. C doesn't give a shit about the hardware.
20:22:37 <AnMaster> Zuu, sure it is. But also the official C standard forbids C from having an infinite state.
20:22:51 <pikhq> C says that your state is finite, even if running on a machine with infinite state.
20:22:53 <AnMaster> it is not a valid, conforming, C implementation then
20:23:27 <pikhq> It can, of course, be obnoxiously large, but it must be finite.
20:25:04 <AnMaster> well then, to anyone who does: it seems that the right way to declare a 32-bit std_logic_vector is: std_logic_vector(4294967296 downto 0) but that seems absurd
20:25:05 <Zuu> ok, give me some hardware with infinite state, and i will write a C program that will act like any universal TC but yet only access a finite set of stats
20:25:22 <Zuu> a C program that conforms 100% to the spec i might add
20:26:16 <Zuu> By assuming that this finite state is large enough to compute whatever needs to becomputed, otherwise go into an infinite loop
20:26:41 <pikhq> Zuu: Minor problem: you are not acting like any universal TC then.
20:26:54 <Zuu> sure, you will get the exact same result ;)
20:26:58 <pikhq> You are acting like a finite state machine.
20:27:36 <pikhq> *It is perfectly possible to just use more memory than your finite state machine has while still halting*.
20:28:02 <pikhq> This is like implementing 32-bit address space by assuming an 8-bit address space is enough, and if that fails, going into an infinite loop.
20:28:11 <Zuu> no the hardware has infinite space, the program will determine if it needs more (finite) memory
20:28:26 <pikhq> *But C does not allow that.*
20:28:40 <Zuu> you said it jsut have to be finite space, not how much finite space
20:28:50 <Zuu> as i explained, i will just assume there is more space
20:28:54 <pikhq> *It must be finite and bound.*
20:29:20 * AnMaster has a crazy idea for how to implement the funge93 stack
20:29:50 <Zuu> Just to be explicit, this argument ended at the sime you gius mentioned the finite state stuff form the spec
20:29:54 <AnMaster> basically... storing the two top values in registers. Memory mapped stack or something...
20:30:04 <pikhq> Okay, so, every time you run out of memory, you recompile and rerun the program with a larger address space?
20:30:08 <Zuu> it just became to rediculous by then
20:30:37 <Zuu> pikhq: that is one way to do it
20:30:53 <AnMaster> well sure what pikhq said works. But then it can be argued to be a different program
20:31:01 <Zuu> AnMaster: ,no
20:31:19 <AnMaster> sure, it is the same source, but it was compiled for a different pointer size
20:31:30 <Zuu> pointer size still doesnt matter
20:31:35 <pikhq> Okay, this is like arguing that an *infinite string of Turing machines with bound, but increasing as you go up the line, tapes* is TC.
20:31:35 <pikhq> While true, you don't have a single TC machine there. You have an infinite string of machines that, in combination, are TC.
20:31:35 <pikhq> And that is a *weird* computational model.
20:32:12 <AnMaster> also #esoteric is _all_ about *weird* computational models
20:32:28 <pikhq> AnMaster: If ever time you overrun the tape you move on to the next machine, yes, you've got that sucker TC.
20:32:32 <AnMaster> just it isn't TC currently, but like Just-In-Time-TC
20:32:56 <pikhq> Equivalent to adding a tape cell each time you hit the end, except *much* less time-efficient.
20:33:15 <AnMaster> pikhq, perfectly valid computational model though.
20:33:29 <pikhq> Weird, but entirely valid.
20:33:37 <Zuu> there are several other ways to achieve UTC though
20:33:49 <AnMaster> pikhq, that C program could even serialise it's own state while waiting for the next pointer size to compile, thus avoiding rerunning the whole thing
20:34:06 <AnMaster> sure it would have to be pointer-size-agnostic
20:34:10 <AnMaster> but that isn't much of an issue
20:34:13 <pikhq> The easiest way to have TC C is to just add the following functions: read_tape(); write_tape();move_left();move_right();
20:34:16 <Zuu> or it could start a sub program to compunicate with
20:34:22 <AnMaster> just use json or some horrible shit
20:34:26 <Zuu> say, and instance of itself
20:34:34 <pikhq> And have those functions deal with an actual tape.
20:34:45 <AnMaster> Zuu, ah but that is not part of C. it is POSIX or win32 or whatever
20:34:53 <pikhq> Still, these amount to *extensions* to C that make it Turing-complete.
20:35:11 <AnMaster> Zuu, C itself doesn't even have the concept of directories after all
20:35:21 <Zuu> AnMaster: you do realize all your excuses barely apply, right?
20:35:23 <AnMaster> and well system() is defined to be implementation defined basically
20:35:31 <AnMaster> Zuu, I think they are very valid
20:35:32 <Zuu> this is theoretical, not a amtter of some random standard
20:35:42 <Zuu> then you think wrong :)
20:35:54 <AnMaster> Zuu, well if we want to be theoretical about C we have to do it in context of some definition of C
20:36:03 <AnMaster> it is called the ISO standard for C
20:36:16 <Zuu> there are actually many versions of those
20:36:17 <AnMaster> Zuu, if you don't accept that then you have to define C some other way
20:36:31 <Zuu> no, im fine with that definition
20:36:36 <AnMaster> Zuu, well okay so which version? K&R? C89/C90? C99?
20:36:51 <Zuu> remember the posic calls are mostly implemented in C aswell
20:36:53 <AnMaster> I think they are all equivalent when it comes to this though.
20:36:59 <pikhq> By the ISO standard for C, C is a finite-state automaton.
20:37:07 <pikhq> Zuu: POSIX defines extensions *to* C.
20:37:14 <Zuu> doesnt amtter
20:37:20 <Zuu> Spelling again :/
20:37:39 <pikhq> Yes it does. It's not C, it's C + POSIX.
20:37:53 <AnMaster> sure if we discuss C + POSIX...
20:37:55 <Zuu> ok, i have far more insterresting stuff to do than tell about ways to use C in a UTC way
20:38:08 <Sgeo__> pikhq, are you joking? How could C merely be a finite-state automaton?
20:38:19 <pikhq> Sgeo__: C is mandated to have finite state.
20:38:26 <AnMaster> Sgeo__, it is true. This was debated for great length in logs
20:38:50 <Zuu> well, nwo you dont have to debate it any more :)
20:38:53 <AnMaster> any given C implementation must be finite
20:39:12 <Sgeo__> Just like an actual physical turing machine can't exist, or worse?
20:39:25 <AnMaster> sure, you can always increase it, but you can never get infinite accessible right now.
20:39:43 <pikhq> Sgeo__: No, more in the way that Befunge-93 must always have finite state.
20:39:58 <pikhq> Except that C doesn't care what the size *is* so long as it's finite.
20:40:29 <AnMaster> Sgeo__, defined in the spec. sizeof(void*) must be finite. CHAR_BITS must be finite. All data must have valid pointers. Thus your address space is at most CHAR_BITS * sizeof(void*) number of bits
20:41:15 <AnMaster> pikhq, so in the same way funge98 would be finite then. Except the spec is fuzzy enough that you can get a bignum implementation in if you try hard enough
20:41:29 <AnMaster> (it takes a LOT of arguing with people)
20:41:34 <Sgeo__> So it's possible to define too many variables?
20:41:41 <Sgeo__> What's the error message for that?
20:41:53 <AnMaster> like possible to malloc too much
20:42:00 <AnMaster> but sure you could have too many variables presumably
20:42:30 <AnMaster> Sgeo__, on a 32-bit machine something like 2 x arrays of 3.9 GB each
20:42:36 <AnMaster> I have no idea what would happen
20:42:43 <AnMaster> probably the compiler would crash with an ICE
20:42:49 <AnMaster> or your system would swap trash
20:43:06 <AnMaster> on a 64-bit system the limit for this would be _much_ higher
20:43:30 <pikhq> AnMaster: Pretty sure Funge98 *allows* for a bignum implementation.
20:43:49 <AnMaster> pikhq, well, I had to argue with cpressy about it being fuzzily enough written to allow it
20:44:04 -!- SgeoN1 has quit (Quit: Bye).
20:44:11 <Deewiant> pikhq: It has a sizeof, which is specced as allowing to return "really really large, infinity, etc."
20:44:15 <AnMaster> pikhq, plus it confuses some programs who have no idea what a cell size of -1 is :P
20:44:27 <pikhq> Deewiant: Oh good. :)
20:44:30 <Deewiant> pikhq: Of course, it doesn't specify how "infinity" should be represented ;-P
20:44:52 <AnMaster> pikhq, Deewiant, yeah I basically declared "infinity" to be equal to -1.
20:45:29 <AnMaster> it was the least insane representation I could think of
20:45:56 <AnMaster> of course it breaks slowdown.b98, which tries to load a program at a random point in the address space and then jump to it
20:45:56 <Sgeo__> How about having it be the maximum value of a cell
20:46:09 <AnMaster> Sgeo__, um.... do you know what a bignum is?
20:46:39 <AnMaster> port(tos_in, sos_in: in std_logic_vector(4294967296 downto 0);
20:46:39 <AnMaster> tos_out, sos_out: in std_logic_vector(4294967296 downto 0);
20:46:52 <Sgeo__> Hm, what prevents storing such a large number in a bugnum that it slows down the computer?
20:47:03 <AnMaster> yes the stack will be finite due to not being able to avoid it
20:47:26 <AnMaster> sure on any given hardware it will be limited
20:47:31 <pikhq> The point of bignums is for it to be possible to be obnoxiously large.
20:47:48 <AnMaster> pikhq, and on an UTM they could be infinite even
20:47:56 <pikhq> Indeed, they could.
20:48:05 <AnMaster> now, someone should port erlang to an UTM :P
20:48:20 -!- augur has joined.
20:48:40 <AnMaster> of course you'd have to rewrite it in another language. Since current implementations are written in C.
20:48:50 <AnMaster> old ones were written in prolog iirc
20:49:06 <AnMaster> (way before erlang went open source)
20:54:42 <Phantom_Hoover> AnMaster: For the Life thing, would it be better to have a hugely parallel collection of cells, or to have a central CPU which evolves some memory?
20:55:24 <AnMaster> Phantom_Hoover, How do you mean with the latter
20:55:39 <AnMaster> Phantom_Hoover, basically a dedicated CPU with some microcode + a lot of SRAM?
20:56:00 <AnMaster> Phantom_Hoover, well, both are interesting IMO
20:56:25 <AnMaster> Phantom_Hoover, want a list of some open source ASIC design tools?
20:56:36 <AnMaster> or do you plan the VHDL thing still
20:56:37 <Phantom_Hoover> AnMaster: The RAM one seems like it's more easily extensible.
20:56:48 <AnMaster> Phantom_Hoover, well, ever heard of the transputer?
20:57:43 <AnMaster> Phantom_Hoover, the transputer was basically grid based. Each CPU talked to the ones in the cardinal directions of it iirc
20:57:53 <AnMaster> (or was it some other connection scheme, but basically yeah)
20:58:41 <AnMaster> Phantom_Hoover, also do you plan to do it at FPGA level or lower level (silicon)
20:58:45 <Phantom_Hoover> In VHDL is there and instruction for "take component x and stick a tonne of them together in a grid".
20:58:59 <AnMaster> Phantom_Hoover, there is some for-generate loop
20:59:10 <AnMaster> Phantom_Hoover, you can _simulate_ both with open source tools
20:59:20 <AnMaster> I don't have access to any FPGAs either currently
20:59:34 <AnMaster> well I do at university, but I doubt I fit this into the lab time ;P
20:59:54 <Phantom_Hoover> Incidentally, I like the "fabricate the grid in a torus" idea.
21:00:09 <AnMaster> Phantom_Hoover, well yeah you would need a lot of small dies
21:00:17 <AnMaster> so you get minimal bend at each
21:00:24 <AnMaster> but overall, you get some bend
21:01:12 <AnMaster> Phantom_Hoover, it was like in the lab recently. Some prankster had taken all the female-female-serial-cable-converters and hooked them up into something that was almost a complete circle
21:01:19 -!- poiuy_qwert has quit (Ping timeout: 245 seconds).
21:01:20 <AnMaster> (not quite enough for a complete circle)
21:01:34 <AnMaster> and then leaned the thing against a wall
21:01:59 <AnMaster> Phantom_Hoover, that circle? Someone having fun. The lab assistant laughed quite loudly when he found it
21:02:42 <AnMaster> since we don't have unsupervised access to that lab room
21:02:49 <AnMaster> (lots of expensive stuff there)
21:03:19 <AnMaster> Phantom_Hoover, oh and ASIC = Application Specific Integrated Circuit
21:03:39 <AnMaster> as in, you get your own in raw silicon. Like the big boys
21:03:56 <AnMaster> yes it is a pain to do even something like a NAND gate in it
21:04:04 <Phantom_Hoover> That is so far out of my league it's approaching it from the other side.
21:04:24 <AnMaster> Phantom_Hoover, THAT IS WHAT SIMULATION IS FOR :(
21:04:55 <AnMaster> electric (wtf gui but I actually was able to do something in it!), magic (heard it was good, never tried it)
21:05:02 <AnMaster> you draw the silicon stuff there
21:05:15 <AnMaster> iirc electric can also generate some of it from simple low level VHDL
21:05:53 <AnMaster> Phantom_Hoover, but yeah better do it at FPGA level. Like, you are more likely to actually pull it off
21:06:25 -!- hiato has quit (Quit: gmote).
21:06:27 -!- poiuy_qwert has joined.
21:06:39 <Phantom_Hoover> I know Verilog in the sense that I can vaguely recognise the syntax.
21:06:48 <AnMaster> Phantom_Hoover, what about VHDL?
21:07:08 <AnMaster> Phantom_Hoover, this might be way out of your league then
21:07:54 <AnMaster> Phantom_Hoover, well there is the clock issue
21:08:05 <AnMaster> especially if you combine multiple ones
21:09:01 <Phantom_Hoover> Given that it's extremely unlikely that I'll ever make a single one.
21:09:06 <AnMaster> doing it async could be possible... but you would be in different generations everywhere
21:09:21 <AnMaster> and you need a lot of tricky stuff to do this in a safe way
21:09:55 <AnMaster> Phantom_Hoover, yeah and that is tricky. I know the theory in a vague kind of way. I know I couldn't pull it off
21:10:14 <AnMaster> Phantom_Hoover, I _also_ know ais523 said he gave a talk on it one day before I asked him about it
21:10:40 <AnMaster> Phantom_Hoover, you know, some university made an async MIPS CPU
21:10:55 <AnMaster> it ran at like 130% or something of the equiv sync
21:11:10 <AnMaster> and adjusted to temperature to always run the fastest possible
21:11:15 -!- kar8nga has joined.
21:11:24 <AnMaster> Phantom_Hoover, like SPARC, x86, PPC or whatever
21:11:45 <AnMaster> Phantom_Hoover, if you have a router or ADSL modem it is not completely unlikely that it contains a MIPS
21:12:05 <AnMaster> they seem to be popular in things like that mostly nowdays
21:14:52 <AnMaster> well, it would be kind of fast
21:15:26 <AnMaster> Phantom_Hoover, so I suggest a clocked parallel one
21:16:35 <AnMaster> Phantom_Hoover, btw can you do hashlife on a torus?
21:17:19 <AnMaster> was trying to parse that a few times
21:17:26 <AnMaster> brb need to get something quick to eat
21:18:47 -!- Tritonio_GR has joined.
21:23:29 <Phantom_Hoover> Yeah, but hashlife in hardware would be a task that would drive a brave man insane
21:24:15 <AnMaster> Phantom_Hoover, a funge stack is near driving me insane
21:24:24 <AnMaster> I could pastebin my current work
21:25:29 -!- augur has quit (Remote host closed the connection).
21:25:55 -!- augur has joined.
21:25:57 <AnMaster> Phantom_Hoover, WIP: http://sprunge.us/VIEd
21:26:10 <AnMaster> and yeah it doesn't currently compile
21:26:21 <AnMaster> I just copied what was in my text editor at that moment
21:26:58 <AnMaster> also I'm not sure what I'm doing is completely valid VHDL
21:27:13 <AnMaster> I think it might need a few cycles. which is irritating
21:27:21 <AnMaster> I was hoping to do it at 1 command / cycle
21:27:28 <AnMaster> but I don't think that will be feasible any more
21:28:42 <AnMaster> also that is async (might have to be rewritten to be sync)
21:32:07 <AnMaster> um yeah needs to be sync... sigh
21:35:11 <AnMaster> how fun. Funge-space is 1 cycle memory. Stack is 2 at least
21:40:58 <AnMaster> src/stack.vhdl:58:62: conversion not allowed between not closely related types
21:42:03 <Deewiant> That can happen if your family tree is too wide; your types become so unrelated that they don't convert to each other
21:42:26 -!- sdorand_ has quit (Quit: sdorand_).
21:45:27 <AnMaster> Deewiant, actually it didn't like unsigned(2047)
21:45:53 <AnMaster> I just converted it by hand to "11111111111"
21:45:57 -!- gm|lap has joined.
21:56:41 <Phantom_Hoover> It would need one bit of storage and 8 in- and outputs.
22:03:40 -!- cheater2 has quit (Ping timeout: 240 seconds).
22:04:01 <AnMaster> 8 inputs, 8 outputs, one clock input
22:04:13 <AnMaster> doing inout would not be a good idea
22:04:45 <AnMaster> a signal that can be both in and out, but you can't really use them both ways at once
22:05:05 <AnMaster> it is used for stuff like data bus on memory
22:05:18 <AnMaster> which depending on if you are in read or write mode will act in different ways
22:05:52 <AnMaster> inout is the vhdl keyword for it
22:07:22 <AnMaster> oh you mean initial programming
22:07:34 <AnMaster> Phantom_Hoover, NO NOT 19 inputs
22:07:51 <AnMaster> inputs and outputs are different
22:08:36 <AnMaster> Phantom_Hoover, you need some way to load the values yes
22:08:50 <AnMaster> Phantom_Hoover, I suggest targeted EMP ;P
22:10:01 <AnMaster> well, you need two I think. Since it is basically a latch. Either you could have one set and one reset. Or you could have one "data bit" and one "load data bit"
22:10:20 <AnMaster> possibly they could be connected in a grid
22:10:39 <AnMaster> that would mean three load inputs for each but a lot easier wiring outside
22:10:56 <AnMaster> basically you have "row active" and "column active"
22:11:05 <AnMaster> then you only read the value if both are true
22:11:30 -!- kar8nga has quit (Remote host closed the connection).
22:11:45 <AnMaster> Phantom_Hoover, I could write the needed cell quite quickly. It actually wouldn't need one output in each direction from a VHDL point of view
22:14:11 * pikhq contemplates adding further optimisations to his compiler
22:14:48 <pikhq> It's currently only barely-optimising, but fairly well setup for a large number of optimisations.
22:14:59 <pikhq> Phantom_Hoover: x86 assembly, nasm format, for Linux.
22:15:43 <pikhq> Written primarily as an amusing timesink.
22:16:03 <pikhq> But I figure if I'm going to amuse myself writing a not-very-useful thing, I might as well do it *well*.
22:16:34 <pikhq> AnMaster: Makes optimisations hard to implement.
22:16:45 <AnMaster> pikhq, still possible. After all bf is TC unlike C
22:16:53 <pikhq> Whereas in C, it's quite simple to write functions over the parse tree.
22:16:58 <pikhq> Possible, yes, but annoying.
22:17:42 <AnMaster> Phantom_Hoover, remind me of the rules for life
22:18:14 <Phantom_Hoover> AnMaster: Dead->live iff 3 live, live->live iff 2 or 3 love.
22:18:20 <pikhq> Phantom_Hoover: Should mostly work.
22:18:52 <pikhq> It's fairly normal C99, aside from the tail-call recursion.
22:18:53 <Phantom_Hoover> It doesn't have IO, so it probably won't work for you.
22:19:07 <AnMaster> Phantom_Hoover, so we just do a Moore automaton in hardware or some such
22:19:17 <pikhq> I either use stdin or a file, and stdout.
22:19:34 <AnMaster> Phantom_Hoover, no dying if too many alive?
22:19:50 <AnMaster> that is some life variant right?
22:19:51 * pikhq looks at some of the optimisations done by esotope
22:21:33 * AnMaster wonders how to get a bit count on a std_logic_vector in vhdl
22:21:45 <pikhq> Hmm. esotope-bfc needs a Brainfuck backend.
22:23:00 <AnMaster> pikhq, it would be hard, since it translates stuff to higher level
22:23:02 <pikhq> esotope-bfc's code isn't that clean. :(
22:23:21 <pikhq> Phantom_Hoover: Best Brainfuck compiler.
22:23:37 <pikhq> Example output: int main(){printf("Hello, world!\n");}
22:25:59 <AnMaster> Phantom_Hoover, meh I can't think of a good way to counts number of set bits in VHDL
22:26:26 <AnMaster> no ways except for creating a counter and checking every bit
22:26:43 <pikhq> It also has very amusing results on hanoi.b
22:26:51 <pikhq> (it's too fast to watch)
22:27:08 <pikhq> It's too fast to watch *with valgrind*.
22:27:20 <AnMaster> pikhq, you have a fast computer
22:27:41 <AnMaster> Phantom_Hoover, well lets say we have 11100000 and 00000111
22:27:47 <AnMaster> Phantom_Hoover, now those are different binary numbers
22:29:17 <pikhq> Phantom_Hoover: Hmm. Probably the Esolang archive.
22:29:38 <pikhq> Otherwise, look for the "bfcomp" package; it's in there.
22:30:08 <pikhq> (it's written in a somewhat high-level language targetting Brainfuck. Produces some ridiculously inefficient output, though.)
22:31:19 <pikhq> Just running a dead-code pass on it knocks out 778 characters...
22:32:43 <AnMaster> elsif present_state = alive and cnt = 2 then
22:33:30 <AnMaster> yeah vhdl has an annoying syntax.
22:37:29 <AnMaster> Phantom_Hoover, okay, done but not tested. (syntax check okay, but test bench code for vhdl takes a while)
22:37:57 <AnMaster> Phantom_Hoover, http://sprunge.us/RVPh
22:38:35 <AnMaster> Phantom_Hoover, that would be one life cell
22:38:46 <AnMaster> pikhq, have a look at that code
22:39:16 <AnMaster> it might be more readable with VHDL syntax highlighting
22:40:19 <AnMaster> Phantom_Hoover, pikhq http://pastebin.com/VLBRYUZc
22:40:41 <AnMaster> the custom dead/alive type could have been skipped
22:40:45 <AnMaster> making the code somewhat more compact
22:40:55 <AnMaster> but that would not be good coding style I think ;P
22:41:29 <AnMaster> I heard verilog has saner syntax
22:42:35 <AnMaster> Phantom_Hoover, so each cell needs to be hooked up to clock and the output from each to the 8 cells next to it
22:42:50 -!- MigoMipo has quit (Read error: Connection reset by peer).
22:42:58 <AnMaster> Phantom_Hoover, oh and I forgot to implement load I see
22:43:31 -!- BeholdMyGlory has quit (Remote host closed the connection).
22:44:38 -!- tombom has quit (Quit: Leaving).
22:46:30 <AnMaster> Phantom_Hoover, okay here is a new one: http://pastebin.com/6AM9MFGD
22:46:43 <AnMaster> since it no longer uses a custom data type it is a lot more compact
22:46:53 <poiuy_qwert> anyone here played Manufactoria: http://jayisgames.com/games/manufactoria/ ?
22:47:11 <pikhq> No, we know not games.
22:47:21 <AnMaster> poiuy_qwert, needs flash. I don't have (nor want) flash. What is it about?
22:47:23 <pikhq> We know not but code.
22:48:09 <AnMaster> Phantom_Hoover, oh and I have no idea whatsoever if that for loop works
22:48:35 <AnMaster> Phantom_Hoover, would of course need a comprehensive test bench testing all possible inputs in both alive and dead state.
22:48:58 <AnMaster> Phantom_Hoover, no CTCP TIME reply?
22:49:12 <AnMaster> Phantom_Hoover, I got no reply
22:49:23 <AnMaster> Phantom_Hoover, what time is it there?
22:53:41 -!- Phantom_Hoover has quit (Ping timeout: 265 seconds).
22:59:14 -!- augur has quit (Ping timeout: 245 seconds).
23:07:07 -!- oerjan has joined.
23:08:08 -!- FireFly has quit (Quit: swatted to death).
23:09:04 <oerjan> !haskell map fromEnum "Å"
23:09:35 <oerjan> !haskell main = print $ map fromEnum "Å"
23:11:22 <oerjan> !haskell main = putStrLn . map toEnum $ map fromEnum "Å"
23:12:08 <pikhq> oerjan: That's a single Unicode codepoint, it just happens to be a UTF-8 character. And Char stores codepoints. :)
23:12:08 <oerjan> huh EgoBot converts from utf-8 on input but not to it on output
23:13:05 <oerjan> pikhq: yes but until recently haskell I/O used Latin-1, not UTF-8
23:13:15 <oerjan> hm what version of ghc is EgoBot using
23:13:44 <oerjan> and the worst thing is that EgoBot now converts from utf-8 on input, but not to it on output
23:14:04 <EgoBot> unknown command ':version'
23:14:14 <EgoBot> Commands available from the prompt:
23:15:26 <EgoBot> syntax: :show [args|prog|prompt|editor|stop|modules|bindings|breaks|context]
23:16:34 -!- Gracenotes has quit (Ping timeout: 248 seconds).
23:33:49 <oerjan> oh wait ghc reads _code_ as utf-8 of course
23:34:22 <HackEgo> Runs arbitrary code in GNU/Linux. Type "`<command>", or "`run <command>" for full shell commands. "`fetch <URL>" downloads files. Files saved to $PWD are persistent, and $PWD/bin is in $PATH. $PWD is a mercurial repository, "`revert <rev>" can be used to revert to a revision. See http://codu.org/projects/hackbot/fshg/
23:34:32 <EgoBot> help: General commands: !help, !info, !bf_txtgen. See also !help languages, !help userinterps. You can get help on some commands by typing !help <command>.
23:34:40 <EgoBot> userinterps: Users can add interpreters written in any of the languages in !help languages. See !help addinterp, delinterp, show | !userinterps. List interpreters added with !addinterp.
23:35:42 <oerjan> !addinterp cp haskell main=interact$show.map fromEnum
23:35:42 <EgoBot> Interpreter cp installed.
23:36:51 <EgoBot> [195,133,32,195,132,32,195,150,32,195,165,32,195,164,32,195,182,10]
23:38:03 <EgoBot> Interpreter cp deleted.
23:41:12 -!- gm|lap has quit (Remote host closed the connection).
23:44:04 <oerjan> !addinterp bytes haskell main=interact$show.map fromEnum
23:44:04 <EgoBot> Interpreter bytes installed.
23:44:32 -!- Gracenotes has joined.
23:51:48 <EgoBot> haskell main=interact$show.map fromEnum