←2020-09-08 2020-09-09 2020-09-10→ ↑2020 ↑all
00:09:45 -!- olsner has joined.
00:24:43 -!- b_jonas has quit (Remote host closed the connection).
00:27:59 <spruit11> 'Do something with format specifiers' they told. 'It'll be fun they' they told me.
00:28:09 <spruit11> Down another rabbit hole.
00:42:11 <imode> I don't see how rule-based programming can be anywhere as fast as imperative programming. the hot loop of searching for which rule to match alone is going to take more time than a single instruction.
00:44:31 <zzo38> Depending on the programming language, it might be possible to make it fast after the program has been compiled.
00:46:47 <imode> I don't see how. my base case is rewrite rules over strings. the matcher logic for a given ruleset can be compiled down to a trie or a DFA, and that can be turned into native code, but in my tests, that's still too slow.
00:48:24 <zzo38> Well, I just made the suggestion.
00:50:09 <imode> yeah... it'd thrash the branch predictor.
00:59:02 <moony> if you're lucky and there's some pattern to it, you might be able to get a Zen (AMD Ryzen/Threadripper/EPYC lines) CPU to cooperate with the branches, but I think that's really it
01:06:41 <spruit11> That's just correct. Usually, rule-based languages or rewriters are slower than imperative programming. But they're still useful.
01:07:53 <spruit11> With Herculean effort you can sometimes compile programs down to their imperative counterpart, though. But usually not.
01:13:33 <imode> doubtful that it's possible with string rewriting.
01:15:01 <spruit11> Depends on the rules and what you think is the imperative counterpart to those rules. But in general, impossible.
01:18:21 <imode> it's sad because there's so many useful things about the paradigm. your state is just the current "fact store" (the string in the case of string rewriting) and the rules that are run against the fact store. how in the hell is prolog performant.
01:22:04 <spruit11> Haskell can do it sometimes. Something like: Take 'fac', analyze it as better strict, compile the matches to conditions, translate the recursion to a loop. Presto, same microcode as the C equivalent.
01:23:15 <spruit11> But that's a whole lot of compiler voodoo. I guess something like 40 manyears to arrive in that state.
01:24:06 <spruit11> The same effort as writing a compiler for a lazy functional language and then attach a normal C compiler with optimizations to it.
01:25:54 <imode> rule based programming is just full of conditions, though. the core loop is just if/else if/else if/else if/else if/else if/... unless you have a reasonable way of shortcutting that linear search.
01:26:53 <imode> even if you compiled that down to assembly, the basis would just be a bunch of branches.
01:30:52 <spruit11> There's a lot of additional voodoo in term rewriters to try and compile most of that out. Mostly -whatsitscalled- deforestation. Just preven intermediate things you match against from ever existing by clever fusion rules.
01:31:07 <spruit11> *prevent
01:42:40 <imode> hm, I should look into that.
01:44:10 -!- salpynx has joined.
01:52:08 -!- olsner has quit (Ping timeout: 256 seconds).
01:55:38 -!- MDude has joined.
02:23:33 -!- olsner has joined.
02:57:22 -!- egelbot has joined.
02:58:04 <spruit11> egelbot: format "{} {}" "hello" "world"
02:58:04 <egelbot> "hello world"
03:23:22 -!- MDude has quit (Quit: Going offline, see ya! (www.adiirc.com)).
03:29:18 -!- egelbot has quit (Remote host closed the connection).
03:29:36 -!- egelbot has joined.
03:30:23 <spruit11> egelbot: format "{} {:#06x}" "a number" 42
03:30:24 <egelbot> "a number 0x002a"
03:30:32 <spruit11> By popular request.
03:47:51 <spruit11> 'Verazol, Parter of Currents' was leaked. Looks interesting.
04:58:12 <esowiki> [[Talk:Emoji]] N https://esolangs.org/w/index.php?oldid=77383 * Tetrapyronia * (+235) Created page with "Do the commands that take input pop the items they use? Ex. Does (add top 2) on the stack (1,2) turn the stack into (1,2,3) or (3)? ~~~~"
04:58:44 -!- Lord_of_Life_ has joined.
05:00:26 -!- Lord_of_Life has quit (Ping timeout: 265 seconds).
05:00:26 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
05:56:56 -!- clog has quit (Ping timeout: 240 seconds).
06:49:13 -!- Sgeo has quit (Read error: Connection reset by peer).
07:19:26 <rain1> hi
07:52:44 -!- clog has joined.
08:01:03 <rain1> Theorem. There are Turing computable partial functions that have no extension to a total Turing computable function. In particular, the partial function f defined so that f(n) = m if and only if the Turing machine with index n halts on input 0 with output m has no extension to a total computable function.
08:02:41 -!- arseniiv has joined.
08:03:04 -!- Melvar has quit (Ping timeout: 246 seconds).
08:06:18 -!- imode has quit (Ping timeout: 256 seconds).
08:13:44 -!- hendursa1 has joined.
08:16:03 -!- hendursaga has quit (Ping timeout: 240 seconds).
08:16:19 -!- Melvar has joined.
08:55:53 <int-e> . o O ( M(T) := if f(T(T)) = 1 then 0 else 1 )
09:09:04 <rain1> so f is just eval([N(0)])
09:09:22 <rain1> M is taking in T and evaling [T(T)(0)] ?
09:09:28 <rain1> and not'ing its result
09:14:12 <int-e> Since f is passing an argument, I guess M should take two arguments, M(T,x) = if f([\x. `T`(`T`,x)]) = 1 then 0 else 1 )
09:14:35 <int-e> And as usual there's a substitution step involved.
09:14:45 <int-e> (as usual in those diagonalization constructions)
09:14:59 <rain1> oh and what properties is this M going to have?
09:15:58 <int-e> Then you look at f([\x. M([M],x)]).
09:16:53 <int-e> Meh, my notation isn't good enough.
09:18:11 <rain1> notationally, this stuff can be pretty awkward
09:18:12 <int-e> But the point is that M is supposed to reconstruct \x. M([M],x) from [M].
09:18:21 <rain1> maybe quasiquotes like in lisp would be good
09:18:23 <int-e> And pass the result to f.
09:19:12 <int-e> so that f([\x. M([M],x)]) = 1 <--> f([\x. M([M],x)]) = 0
09:34:59 -!- kritixilithos has joined.
09:39:57 <kritixilithos> rain1: what's meant by 'extension'?
10:12:23 -!- kritixilithos has quit (Ping timeout: 240 seconds).
10:28:25 -!- salpynx has quit (Remote host closed the connection).
11:30:22 <rain1> kritixilithos
11:30:37 <rain1> f(x) is defined for some values and the turing machine does not halt so it is not defined for other values
11:30:58 <rain1> an extension is a function that matches it on defined values, and may terminate and produce values on f's undefineds
11:31:12 <rain1> i was thinking how nice it would be to assign types to turing machise
11:31:20 <rain1> just like <Ty> ::= N | <Ty> -> <Ty>
11:32:40 <rain1> but you can't really do this
11:33:04 <rain1> the liar program essentially depends on you putting T(T(T(T(...))) basically an infinite type/non well founded type
11:33:58 <rain1> intuitive concepts are matched up with formal things on the arithmetic heierearchy
11:34:28 <rain1> decidable set: t.m. halts with 1 if element is in the set, 0 if element is not in the set -- this is a Delta_0^1 set
11:34:32 -!- kritixilithos has joined.
11:34:48 <rain1> semidecidable set: t.m. halts with 1 if element is in the set, diverges if not -- this is a Sigma_0^1 set
11:35:32 <rain1> the set of all total computable functions: every element of this set is a t.m. that halts on all inputs - this is suppose to be Pi_2
11:35:46 <rain1> I don't really know why yet
11:35:53 <rain1> I need to study posts theorem
11:36:05 <rain1> and I need to know about turing jumps (?)
11:48:03 <kritixilithos> rain1: thanks for the definition. curious, what resources are you using to learn about this?
11:51:48 -!- hendursa1 has quit (Quit: hendursa1).
11:52:11 -!- hendursaga has joined.
12:18:23 -!- kritixilithos has quit (Ping timeout: 240 seconds).
12:28:31 <rain1> wikipedia.. :<
12:28:35 <rain1> i need a better resource
12:58:54 -!- kritixilithos has joined.
13:10:03 -!- joast has quit (Quit: Leaving.).
13:11:27 <rain1> I think the halting problem proof can be done at any level
13:11:33 <rain1> so lets call normal one level 0
13:11:38 <rain1> we showed Halt does not exist at level 0
13:11:56 <rain1> but assume Halt exists at level 1 (i.e. level 1 is turing machines with a halting oracle)
13:12:11 <myname> it can be
13:12:18 <myname> there is an esolang with that premise iirc
13:12:20 <rain1> we can't implement Halt_1 at this level
13:12:30 <rain1> Halt_1 being a decision procedure that tells you if a level 1 machine halts
13:12:46 <rain1> and we just use the same proof as the normal halting problem proof?
13:13:03 <myname> yes
13:13:17 <myname> for each halting problem level you can solve, you will create a new one
13:13:24 <rain1> this is good
13:21:30 <rain1> how does this relate to arithmetic heierarchy
13:22:20 -!- joast has joined.
13:22:30 <kritixilithos> "<rain1> i need a better resource" i had started https://www.comp.nus.edu.sg/~fstephan/recursiontheory-pdflatex.pdf a while back
13:22:45 <rain1> oh yeah i remember this
13:22:50 <rain1> thanks!
13:25:36 <kritixilithos> some proofs however aren't shown in full, so i took a break from it to start reading another book
13:30:10 <kritixilithos> but then again, asking for a proof that diophantine sets are r.e. might be a bit too much
13:32:45 <rain1> there is a good book on that, hilberts 10th problem
13:32:59 <rain1> the hardest part was finding a way to express exponentiation
13:35:18 <kritixilithos> thanks, might take a look into that later
13:49:04 -!- adu has joined.
13:56:03 -!- kritixilithos has quit (Ping timeout: 240 seconds).
14:01:07 -!- egelbot has quit (Remote host closed the connection).
14:08:15 -!- kritixilithos has joined.
14:17:05 -!- Sgeo has joined.
14:32:27 -!- arseniiv has quit (Quit: gone too far).
14:35:28 <esowiki> [[THE LAST ACTION LANGUAGE]] N https://esolangs.org/w/index.php?oldid=77384 * Zero * (+2184) Created page with " = THE_LAST_ACTION_LANGUAGE = == overview == * natural-language agnostic (all keywords are 1 special character) so you can program in Toki Pona * values are mutabl..."
14:36:03 -!- hendursaga has quit (Ping timeout: 240 seconds).
14:37:18 -!- hendursaga has joined.
14:40:22 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77385&oldid=77384 * Zero * (+3)
14:42:51 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77386&oldid=77385 * Zero * (+93)
14:43:21 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77387&oldid=77386 * Zero * (+12)
14:48:08 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77388&oldid=77387 * Zero * (+57)
14:49:22 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77389&oldid=77388 * Zero * (+23)
14:57:14 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77390&oldid=77389 * Zero * (+55)
15:10:15 -!- MDude has joined.
15:16:46 <rain1> the terminology is so slippery
15:16:57 <rain1> i feel like any source uses a slightly different set of terms
15:18:03 <kritixilithos> which ones do you specifically mean?
15:18:45 <rain1> just stuff like recursive, semidecidable, recursively enumerable, etc.
15:19:38 <kritixilithos> huh i haven't yet seen another source mean something different for any of those
15:20:42 -!- oshaboy has joined.
15:23:23 -!- arseniiv has joined.
15:23:27 -!- Arcorann_ has quit (Read error: Connection reset by peer).
15:33:10 -!- grumble has quit (Ping timeout: 606 seconds).
15:33:40 -!- grumble has joined.
15:34:46 <rain1> I am homing in on the result I was interested in
15:35:00 <rain1> https://imgur.com/a/ZuvsRyf
15:37:34 <kritixilithos> where is that from?
15:37:50 <rain1> R.E. sets and degrees - Robert Soare
15:39:13 <rain1> i dont know if id recommend it
15:39:28 -!- S_Gautam has joined.
15:39:31 <rain1> i just want to know this one thing
15:39:39 <rain1> but it seems to depend on a lot of theory
15:41:04 <kritixilithos> what is it that you want to know?
15:41:08 <rain1> its hard to untangle the notation
15:41:30 <rain1> I want a proof that the "uniform halting problem" is harder than the halting problem
15:41:43 <rain1> by UHP i mean: Deciding whether a turing machine halts on all inputs
15:42:06 <rain1> determining if a turing machine halts on N inputs (for any finite N) is equivalent to the halting problem
15:42:14 <rain1> but for all inputs it seems to be harder
15:42:33 <kritixilithos> okay, i haven't yet learnt about "hardness"
15:42:59 <kritixilithos> oh you mean to prove they're not equivalent
15:43:01 <rain1> by harder I mean that we can't compute it even if we have a halting oracle
15:43:25 <rain1> yeah
15:49:05 <fizzie> The Mohs scale of computational hardness.
15:50:00 <kritixilithos> :|
15:53:22 <rain1> I would like a self contained proof of Posts theorem
15:53:34 <rain1> it's annoying to have to read 3 chapters of a book just to have the notation for this theorem
15:55:54 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77391&oldid=77390 * Zero * (+20)
15:57:49 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77392&oldid=77391 * Zero * (+9)
15:58:56 <rain1> I think I can ask a really good question now
15:59:29 <rain1> How does a Turing machine with a Halt_1 oracle decide if a Turing machine halts on all inputs?
15:59:46 <rain1> A Halt_1 oracle means that we have the ability to decide if any Turing Machine with a halting oracle halts or not
16:00:42 <kritixilithos> ah, so the first level halting oracle is Halt_0?
16:02:51 <rain1> yeah
16:03:10 <rain1> so we have 3 levels here: Basic TMs, TMs with a halting oracle (halt0), TMs with a halt1 oracle
16:03:52 <rain1> level0 1 and 2
16:04:10 <rain1> So we can implement some kind of level1 TM and ask if it halts to decide something about a level0 machine
16:05:05 <kritixilithos> did you figure it out yet?
16:05:16 -!- b_jonas has joined.
16:06:29 <rain1> no I just managed to ask this question which crystalizes exactly what I want to know
16:07:51 <rain1> although I need to prove 2 things actually: That the problem is not solvable on level 1 and it is solvable on level 2
16:09:47 <rain1> I think this works
16:10:00 <rain1> def X(T : TM_0):
16:10:07 <rain1> for n = 0 and up:
16:10:26 <rain1> if !Halt0('T(n)'): return
16:10:54 <rain1> now when we ask Halt1(X(T)) we get an answer to whether T halts on all inputs or not
16:11:33 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77393&oldid=77392 * Zero * (+1393)
16:12:57 <kritixilithos> sounds like it, now for the first part
16:13:45 <rain1> the first part may be harder
16:13:55 <rain1> hopefully it is solvable
16:14:57 <rain1> So assume for contradiction that we can decide if a TM halts on all inputs or not, at level 1
16:15:27 <rain1> Then we have a total procedure Tot(T : TM0) which returns 0 if it's input is not total and 1 if it is
16:15:43 <rain1> we also have access to a halting oracle (Tot will have been implemented using this)
16:16:00 <rain1> so now it would be nice to perform some kind of diagonalization/liar construction to show this cannot happen
16:17:23 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77394&oldid=77393 * Zero * (+249)
16:20:23 <b_jonas> "<spruit11> 'Do something with format specifiers' they told." => I'm sorry, you must have misunderstood me. I did mention formatted numeric output, but I didn't specifically mention format specifiers, it could have been raw format primitives too, and I would certainly never suggest new python style braced format specifiers, I HATE those, they're ruining the whole purpose of format specifiers that C and
16:20:29 <b_jonas> python perfected and making a mocking parody from them. If anyone told me they want to do a format parser, I'd suggest them to use C-like percent escapes (or common lisp-like tilde escapes if they prefer)
16:21:40 <b_jonas> nor would I ever suggest you to use a vararg formatting function in a curried language
16:22:38 <b_jonas> I program python, and I use the C-like formatting function, which is still there and supported and works *almost* well, except that for some reason they haven't added hex float output format to it yet, but that shouldn't be hard to fix
16:23:04 <rain1> one thing I would say is that it seems very hard to do a simple diagonalization proof
16:23:14 <rain1> because our primitive can only be applied to stuff at the level below
16:23:25 <rain1> whereas with turings proof: we assume halt can be applied to our own levle
16:23:35 <b_jonas> but even if you have a format parser, I'd suggest to add the underlying primitives to the public API too, so people can write their own format parser, and format afloating-point numbers in decimal without having to make a format pattern from it
16:24:39 <esowiki> [[Modulous]] M https://esolangs.org/w/index.php?diff=77395&oldid=76969 * Abyxlrz * (+1)
16:25:01 <b_jonas> spruit11: ^
16:25:21 <b_jonas> on the other hand, this might still be more useful than nothing.
16:26:01 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77396&oldid=77394 * Zero * (+353)
16:26:05 <b_jonas> egelbot: (format "{:c}" 67)
16:26:13 <b_jonas> oh yeah
16:26:26 <spruit11> Oh, right.
16:26:47 -!- egelbot has joined.
16:26:54 <spruit11> There you go.
16:27:15 <rain1> could we use a relative rice theorem?
16:28:59 <spruit11> egelbot: (format "{:c}" 67)
16:28:59 <egelbot> "C"
16:30:09 <spruit11> egelbot: def box = [ 0 -> nil | N -> cons (N-1) (box (N-1)) ];; def map = [ F nil -> nil | F (cons X XX) -> cons (F X) (map F XX) ];; map [ X -> format "{:#04x}" X ] (box 16)
16:30:09 <egelbot> {"0x0f", "0x0e", "0x0d", "0x0c", "0x0b", "0x0a", "0x09", "0x08", "0x07", "0x06", "0x05", "0x04", "0x03", "0x02", "0x01", "0x00"}
16:34:14 -!- xelxebar has quit (Remote host closed the connection).
16:34:45 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77397&oldid=77396 * Zero * (+387)
16:35:54 <spruit11> b_jonas: No worries. It wasn't actually yours or mine decision in the end. I either a) drop to C internally, which is awkward, b) use C++ stream specifiers, which is hard to work with/a lot of work, or c) use C++20 braced format. I didn't really have a choice except choose the last one.
16:36:25 -!- xelxebar has joined.
16:36:50 <spruit11> I like them. Good enough.
16:37:31 <spruit11> I just wish I coud use them in the reverse direction too. To read input.
16:37:34 <spruit11> *could
16:38:55 <kritixilithos> https://cs.stackexchange.com/q/129977 :)
16:40:06 <spruit11> And I like the variadic stuff too. So we just disagree on that.
16:40:43 <spruit11> egelbot: format "{1} {0} {1}" 1 2
16:40:43 <egelbot> "2 1 2"
16:41:26 <b_jonas> spruit11: yes, to some extent the interfaces in the C and C++ standard library are awkward too. But formatting floating point numbers correctly is so hard that I don't recommend anyone to reimplement it. Even if you make a whole format library, you often want to do those, there are countless precedents of programs that do that even if on windows you have to work around the weird float printer of windows
16:41:32 <b_jonas> libc (which always prints three digits for the exponent and prints infs and nans weirdly) and have to work around libc on linux (in which the formatter works fine, but the scanner has some weird behavior that is probably correct and can't be changed now but nobody really knows what the correct behavior of fscanf should be and how to fix problems when you have to be compatible with old programs).
16:41:38 <b_jonas> egelbot: (format "{:c}" 67)
16:41:38 <egelbot> "C"
16:41:42 <b_jonas> egelbot: (format "{:c}" 65)
16:41:42 <egelbot> "A"
16:41:51 <b_jonas> great, so we have an easier way to chr now
16:42:07 <spruit11> I am sure C++40 will once get format right. Seems a good bet.
16:42:09 <b_jonas> egelbot: (format "{:c}-{:c}" 0xE1 0x151)
16:42:09 <egelbot> internal:1:24:lexical:error in hexadecimal int
16:42:16 <spruit11> lowercase
16:42:22 <b_jonas> I refuse
16:42:33 <spruit11> I'll add then once.
16:42:39 <b_jonas> egelbot: (format "{:c}-{:c}" 225 337)
16:42:39 <egelbot> "�-Q"
16:42:46 <b_jonas> nope
16:42:47 <spruit11> It's still in alpha!
16:43:24 <b_jonas> ok, so how do I make utf-8 formatted characters from their ucs code point, is there a different formatter for that?
16:43:30 <b_jonas> egelbot: (format "{:C}-{:C}" 225 337)
16:43:30 <egelbot> exception("System:format invalid arguments")
16:43:34 <b_jonas> egelbot: (format "{:lc}-{:lc}" 225 337)
16:43:34 <egelbot> exception("System:format invalid arguments")
16:43:42 <spruit11> Dunno. I hardly tested.
16:44:26 <spruit11> https://en.cppreference.com/w/cpp/utility/format/format
16:44:30 <b_jonas> egelbot: (format "{:c}{:c}-{:c}{:c}" 195 161 197 145)
16:44:30 <egelbot> "á-ő"
16:44:33 <b_jonas> that's better
16:44:42 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77398&oldid=77397 * Zero * (+228)
16:44:54 <b_jonas> that means I can output arbitrary bytes
16:45:02 <b_jonas> well, I hope
16:45:21 <b_jonas> egelbot: String:append (format "{:c}" 195) (format "{:c}" 161)
16:45:21 <egelbot> "��"
16:45:23 <b_jonas> nope
16:45:35 <b_jonas> apparently only valid utf-8, it gets decoded from utf-8 right after format
16:45:39 <b_jonas> oh well
16:46:09 <b_jonas> it's not like I really care about this part
16:46:15 <b_jonas> let me see what else you did
16:47:00 <rain1> I feel really happy because this question has made me realize just how little I know about turing machines an
16:48:00 <spruit11> That's about it. I spend a day or two making the interpreter a bit faster. But you won't notice that.
16:48:56 <kritixilithos> are you going to ask your other question?
16:49:35 <b_jonas> egelbot: [v->format "{.2f} {.8f} {.2g} {.8g} {.2e} {.8e}" v v v v v v] -8862.395521078714
16:49:35 <egelbot> internal:1:3:semantical:undeclared v
16:49:46 <spruit11> Uppercase.
16:49:48 <b_jonas> egelbot: [V->format "{.2f} {.8f} {.2g} {.8g} {.2e} {.8e}" V V V V V V] -8862.395521078714
16:49:48 <egelbot> exception("System:- bad arguments")
16:50:08 <b_jonas> egelbot: [V->format "{:.2f} {:.8f} {:.2g} {:.8g} {:.2e} {:.8e}" V V V V V V] -8862.395521078714
16:50:08 <egelbot> exception("System:- bad arguments")
16:50:13 <spruit11> Oh, darn. I forgot to add a rewrite rule for monadic minus.
16:50:21 <spruit11> That's a bug.
16:50:22 <b_jonas> egelbot: [V->format "{:.2f} {:.8f} {:.2g} {:.8g} {:.2e} {:.8e}" V V V V V V] (-8862.395521078714)
16:50:22 <egelbot> "-8862.40 -8862.39552108 -8.9e+03 -8862.3955 -8.86e+03 -8.86239552e+03"
16:50:38 <b_jonas> that looks correct
16:50:40 <spruit11> I didn't forget?
16:50:42 <b_jonas> egelbot: [V->format "{:.2f} {:.8f} {:.2g} {:.8g} {:.2e} {:.8e}" V V V V V V] (-8862.395)
16:50:42 <egelbot> "-8862.40 -8862.39500000 -8.9e+03 -8862.395 -8.86e+03 -8.86239500e+03"
16:51:01 <spruit11> Oh, it interpreted that as a dyadic minus expression.
16:51:38 <spruit11> [X->X] -2 = [X->X] - 2.
16:51:40 <b_jonas> egelbot: [V->format "{:#.2f} {:#.8f} {:.2f} {:.8f} {:.2g} {:.8g} {:.2e} {:.8e}" V V V V V V V V] (-8862)
16:51:40 <egelbot> exception("System:format invalid arguments")
16:51:49 <b_jonas> egelbot: [V->format "{:.2#f} {:.8#f} {:.2f} {:.8f} {:.2g} {:.8g} {:.2e} {:.8e}" V V V V V V V V] (-8862)
16:51:49 <egelbot> exception("System:format invalid arguments")
16:52:00 <b_jonas> hmm
16:52:40 <b_jonas> egelbot: [V->format "{:.2f} {:.8f} {:.2g} {:.8g} {:.2e} {:.8e}" V V V V V V] (-8862)
16:52:40 <egelbot> exception("System:format invalid arguments")
16:52:42 <spruit11> It's still a bit rough around the edges. The C++ format throws an error on that of which I don't propagate the message.
16:52:56 <b_jonas> ?
16:53:18 <b_jonas> egelbot: [V->format "{:.2f} {:.8f}" V V] (-8862)
16:53:18 <egelbot> exception("System:format invalid arguments")
16:53:31 <spruit11> It only says 'invalid arguments' whereas I probably could give a more descriptive error.
16:53:34 <b_jonas> egelbot: [V->format "{:.2f}" V] (-8862)
16:53:34 <egelbot> exception("System:format invalid arguments")
16:53:55 <b_jonas> egelbot: [V->format "{:.2f} {:.8f} {:.2g} {:.8g} {:.2e} {:.8e}" V V V V V V] (-8862.395)
16:53:55 <egelbot> "-8862.40 -8862.39500000 -8.9e+03 -8862.395 -8.86e+03 -8.86239500e+03"
16:54:15 <b_jonas> egelbot: [V->format "{:.2f}" V] (-8862.395)
16:54:15 <egelbot> "-8862.40"
16:54:24 <b_jonas> egelbot: [V->format "{:.2f}" V] (-8862.0)
16:54:24 <egelbot> "-8862.00"
16:54:25 <b_jonas> oh
16:54:28 <b_jonas> egelbot: [V->format "{:.2#f}" V] (-8862.0)
16:54:28 <egelbot> exception("System:format invalid arguments")
16:54:31 <b_jonas> egelbot: [V->format "{:#.2f}" V] (-8862.0)
16:54:31 <egelbot> "-8862.00"
16:54:34 <b_jonas> that's better
16:54:40 <b_jonas> egelbot: [V->format "{:#f}" V] (-8862.0)
16:54:40 <egelbot> "-8862.000000"
16:54:44 <b_jonas> egelbot: [V->format "{:#g}" V] (-8862.0)
16:54:44 <egelbot> "-8862.00"
16:54:59 <b_jonas> egelbot: [V->format "{:#g}" V] (-8862449.0)
16:54:59 <egelbot> "-8.86245e+06"
16:55:02 <b_jonas> egelbot: [V->format "{:#g}" V] (-886244.0)
16:55:02 <egelbot> "-886244.0"
16:55:05 <b_jonas> egelbot: [V->format "{:#g}" V] (-886244.2)
16:55:06 <egelbot> "-886244.0"
16:55:11 <b_jonas> perfect
16:55:14 <b_jonas> egelbot: [V->format "{:g}" V] (-886244.2)
16:55:14 <egelbot> "-886244"
16:55:50 <spruit11> Well, it's not my doing. It's the `fmt` library they're adding to C++20 once.
16:56:09 <spruit11> Okay, it's my doing in that I want to leverage C++.
16:56:15 <b_jonas> egelbot: [V->format "{:d} {:X}" V V] 2769927127
16:56:15 <egelbot> "2769927127 A519BBD7"
16:56:21 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77399&oldid=77398 * Zero * (+384)
16:56:30 <b_jonas> correct
16:56:33 * V makes a pained face
16:58:12 <int-e> `? spam
16:58:14 <HackEso> Spam is a delicious meat product. See http://www.spamjamhawaii.com/
16:58:18 <spruit11> egelbot: format "{0} {0}" "∀"
16:58:18 <egelbot> "∀ ∀"
16:58:28 -!- Lord_of_Life_ has joined.
16:59:38 <b_jonas> egelbot: format "%X" 15898557144921403118
16:59:38 <egelbot> "%X"
16:59:44 <b_jonas> egelbot: format "{:X}" 15898557144921403118
16:59:44 <egelbot> "7FFFFFFFFFFFFFFF"
16:59:52 <b_jonas> egelbot: 15898557144921403118
16:59:52 <egelbot> 9223372036854775807
17:00:01 <b_jonas> egelbot: 1<<63
17:00:01 <egelbot> -9223372036854775808
17:00:21 <b_jonas> it just saturates integer literals that are too large? interesting
17:00:33 <spruit11> 64 bit ints yeah.
17:00:53 <spruit11> I could replace that with bigints once but I won't.
17:00:56 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77400&oldid=77399 * Zero * (+249)
17:01:26 -!- Lord_of_Life has quit (Ping timeout: 264 seconds).
17:01:26 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
17:01:32 <b_jonas> egelbot: (-9223372036854775808)
17:01:32 <egelbot> -9223372036854775808
17:01:40 <b_jonas> egelbot: 9223372036854775808
17:01:40 <egelbot> 9223372036854775807
17:01:51 <b_jonas> egelbot: format "{:X}" -1538786743794826979
17:01:51 <egelbot> exception("System:format invalid arguments")
17:01:57 <b_jonas> egelbot: format "{:X}" (-1538786743794826979)
17:01:57 <egelbot> "-155ADE6400F87EE3"
17:02:01 <b_jonas> ?
17:02:05 <b_jonas> definitely not
17:02:29 <b_jonas> ok, maybe
17:03:02 <b_jonas> so it formats a signed 64-bit value, not an unsigned one
17:03:09 <b_jonas> how you would get libc to do that I have no idea
17:03:15 <b_jonas> oh well
17:03:54 <b_jonas> I mean it doesn't even have format specifiers that format a signed integer as hex, if you try the number just gets interpreted as an unsigned number
17:05:29 <spruit11> Heh? Not sure what you asking but `fmt` defines the handlers for a large number of basic C types. So this is the handler which formats signed 64 bit integers.
17:05:53 <spruit11> Well, according to the system you're on.
17:06:18 <spruit11> egelbot: format "{}" {1}
17:06:18 <egelbot> "{1}"
17:06:24 <b_jonas> spruit11: which fmt? I mean libc's printf doesn't define such formatters. other formatting libraries might.
17:06:57 <spruit11> `fmt` is the library they're adding to C++20 as `std::format`.
17:06:57 <HackEso> fmt`? No such file or directory
17:07:03 <spruit11> It's what I use.
17:08:43 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77401&oldid=77400 * Zero * (+773)
17:11:39 <b_jonas> oh yeah, another of those
17:14:50 <fizzie> Hey, I think I used fmt for something. It seemed sane.
17:15:15 -!- aaaaaa has joined.
17:15:43 <spruit11> The compilers are a bit slacking in adoption of it. But it's fine. I just ship with `fmt` for the moment.
17:16:53 <spruit11> Most of the work was looking whether it was implemented and then incorperating `fmt` instead.
17:17:28 <spruit11> Pretty sure by C++40 you'll have all the format specifiers you want.
17:22:30 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77402&oldid=77401 * Zero * (+513)
17:22:43 <b_jonas> spruit11: you can probably use an implementation that's not in libstdc++ but elsewhere, such as in boost, that is close enough
17:23:00 <b_jonas> possibly with a namespace alias so it's easy to switch it over to a different implementation
17:23:24 <spruit11> I want to keep my dependencies to a minimum. I am already getting unsatisfied with libicu.
17:23:30 <fizzie> Near the end of the century, it's going to get seriously confusing how the 2096 C++96 actually post-dates C++98. The same with C standards.
17:23:33 <fizzie> IMO, they should've called C11 -> C111, C18 -> C118, C2x -> C12x. If it's good enough for tm_year, it should be good enough for standard abbreviations as well.
17:24:09 <fizzie> That would have also meant that publishing a new C standard in 2028 could've given us a C128.
17:25:03 <b_jonas> that said, I like C printf
17:25:17 <b_jonas> it's not perfect, but it's usually good enough
17:25:17 <spruit11> Makes two of us.
17:25:25 <b_jonas> better than most of the nonsense that they put in newer languages
17:26:01 <spruit11> Heh, I just assume there's some sanity behind it.
17:26:06 <aaaaaa> fizzie: upvote
17:31:15 -!- kritixilithos has quit (Quit: quit).
17:33:09 <zzo38> SQLite has its own printf, which can be called from C codes and from SQL codes. It is mostly like the C printf.
17:35:42 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77403&oldid=77402 * Zero * (+698)
17:36:34 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77404&oldid=77403 * Zero * (+13)
17:38:12 -!- LKoen has joined.
17:44:28 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77405&oldid=77404 * Zero * (+451)
17:46:52 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77406&oldid=77405 * Zero * (-14)
17:48:42 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77407&oldid=77406 * Zero * (+1)
17:56:38 <esowiki> [[THE LAST ACTION LANGUAGE]] M https://esolangs.org/w/index.php?diff=77408&oldid=77407 * Zero * (-1)
17:58:23 -!- hendursaga has quit (Ping timeout: 240 seconds).
17:58:50 -!- S_Gautam has quit (Quit: Connection closed for inactivity).
18:00:53 <esowiki> [[THE LAST ACTION LANGUAGE]] M https://esolangs.org/w/index.php?diff=77409&oldid=77408 * Zero * (+10)
18:01:03 -!- hendursaga has joined.
18:07:56 <kmc> fizzie: bold of you to assume that human civilization will survive to 2096
18:09:20 <kmc> right now the sky outside my window is a dark orange color
18:09:26 <kmc> light level comparable to an hour or more before sunrise
18:09:31 <kmc> it is 11 AM
18:09:36 <kmc> see also every photo on https://www.reddit.com/r/bayarea/
18:10:07 <int-e> nice scifi book cover
18:10:30 <int-e> just add a few flying cars
18:10:38 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77410&oldid=77409 * Zero * (+189)
18:10:42 <fizzie> Reminds me of Beneath A Steel Sky for some reason.
18:11:12 <fizzie> (I don't even think it has any scene quite like that.)
18:13:23 <kmc> my friend texted me this morning "Is there life on Mars?"
18:13:26 <int-e> oh... Joey.
18:19:09 <kmc> this is why I'm learning to grow mushrooms.
18:19:12 <kmc> they don't require sunlight
18:19:14 <kmc> not much, anyway
18:19:41 <int-e> fizzie: well, there's this in the intro: https://int-e.eu/~bf3/tmp/bass1.png
18:20:49 <int-e> somehow, I don't remember all that much of this game
18:22:22 <fizzie> Oh, maybe I subconsciously remembered that or something.
18:24:05 <fizzie> I sort of remember it had that thing where lower-class people live on the lower levels of the city, and you needed to work your way up (via puzzles, naturally).
18:24:36 <int-e> ah yes.
18:24:56 <int-e> but most of it takes place indoors in steel blue decor
18:25:57 <fizzie> Oh, they've got a sequel out, like, just recently? Didn't know that at all.
18:28:33 <int-e> Hmm, could be interesting.
18:31:08 <int-e> In a couple of years, I guess.
19:01:54 -!- xelxebar has quit (Remote host closed the connection).
19:02:17 -!- xelxebar has joined.
19:20:45 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77411&oldid=77410 * Zero * (-1)
19:47:13 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77412&oldid=77411 * Zero * (+1)
19:49:39 -!- imode has joined.
19:56:26 -!- LKoen has quit (Remote host closed the connection).
20:11:06 -!- oshaboy has quit (Quit: Leaving).
20:15:29 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77413&oldid=77412 * Zero * (+361)
20:18:48 <esowiki> [[THE LAST ACTION LANGUAGE]] https://esolangs.org/w/index.php?diff=77414&oldid=77413 * Zero * (+35)
21:21:49 -!- arseniiv has quit (Ping timeout: 264 seconds).
21:29:34 -!- aaaaaa has quit (Quit: leaving).
21:49:48 <zzo38> Next in GURPS game, we have to stop some kind of operation in a black tower; apparently with enough power, the tower will "activate". One of my ideas was to damage the tower itself to create structural weaknesses, but what do you think is the best way to try to do that?
22:07:31 <kmc> depends on what the tower is made from
22:08:32 <zzo38> Yes, I thought that too, and unfortunately I don't know, but I know that it is black.
22:20:05 -!- adu has quit (Quit: adu).
22:36:15 -!- Arcorann_ has joined.
22:37:15 -!- Arcorann_ has quit (Remote host closed the connection).
22:37:40 -!- Arcorann_ has joined.
22:50:43 -!- LKoen has joined.
23:00:12 -!- Sgeo_ has joined.
23:02:54 -!- Sgeo has quit (Ping timeout: 260 seconds).
23:04:05 -!- adu has joined.
23:48:16 <int-e> Oh, "platform security" = "vendor lock-in"? Nobody could foresee that... https://www.servethehome.com/amd-psb-vendor-locks-epyc-cpus-for-enhanced-security-at-a-cost/
23:53:58 -!- LKoen has quit (Quit: “It’s only logical. First you learn to talk, then you learn to think. Too bad it’s not the other way round.”).
←2020-09-08 2020-09-09 2020-09-10→ ↑2020 ↑all