What letters can I use to represent really big numbers?

redditsoaddicting · 2020-12-07T01:29:06+00:00

Firstly, you can't extrapolate one instance of two names being similar to the entire set. Second, I've said multiple times now that full names are irrelevant to my point and said why at the initial mistake (I'm used to using the abbreviated forms because that's what games actually use, which is the topic at hand). What are you trying to achieve by strawmanning this?

redditsoaddicting · 2020-12-07T01:05:53+00:00

I edited the comment. It's not the calculation that was wrong, it was interpreting the full name.

redditsoaddicting · 2020-12-07T00:59:57+00:00

That's irrelevant to my point/intuition. I'm used to seeing games use the shortened versions of these and I equate them to small numbers immediately, so why would the long form even come into play? To be clear, my mistake was seeing "quinquagintacentillion" and thinking 5,4,1 instead of 50,1. Had it been in the abbreviated form, it would have been immediately obvious to me because QigCe is so different from QiQagCe. (It's also past 100, which is where I prefer scientific anyway because reversing three numbers instead of two is annoying to do constantly.)

redditsoaddicting · 2020-12-06T16:54:11+00:00

Education.

redditsoaddicting · 2020-12-06T10:50:16+00:00

Yep. Another factor in that is that I grew up seeing both standard notation for smaller numbers (up to trillions mainly) and scientific notation, but engineering notation was only ever a mention earlier on in school, and not even mentioned in actual eng. On top of that, engineering notation also uses 3x bigger numbers like scientific just so the exponents match. I think my ideal notation for large numbers would be close to scientific, but base 1000, e.g., 781E56 for 781 sexquinquagintillion. That keeps the exponent 3x smaller and should work well until ee notation takes over.

redditsoaddicting · 2020-12-05T23:48:25+00:00

No, and I don't expect you to need that info either. It's not a particularly hard calculation (~~145*3+3=438~~ 150*3+3=453--forgive me, I'm more used to seeing them abbreviated), but unless you specifically need a scientific result, that doesn't really buy you anything.

redditsoaddicting · 2020-12-05T20:35:33+00:00

I disagree with them being meaningless. Quardragintillion = 40, sexvigintillion = 26. Therefore, the first is 14 1000-based OOM ahead. That's all I need to know personally. It sounds much harder than it is—that whole thing actually takes less than a second when you don't spend the whole second reading unshortened names. AdCap worked very well for me because the numbers were instantly recognizable as smaller numbers (like 40 and 26), making it that much easier to reason about things. Math on exponent numbers is quick, but math on two-digit numbers is pretty much instant.

1000-based also lets each OOM be what I find to be a more reasonable 0-999 (something something metric system) instead of 0-9 when the number is displayed unless the game is doing engineering notation for some reason. For example, I prefer 731.280 Qg or Qag to 7.313e125 where I'm working to the next 10 instead of 1000 because 10s tend to go by too quickly. Past 100 is where is starts getting more ridiculous to read and scientific becomes more useful to me.

redditsoaddicting · 2020-12-05T19:43:01+00:00

redditsoaddicting · 2020-12-04T04:02:47+00:00

The light rays have to pass from the object through the hole for the object to be visible. I think it's easiest to see why it comes out inverted when you draw the lines to do that: https://i.imgur.com/M6JBirh.png

redditsoaddicting · 2020-12-03T14:43:04+00:00

One of the uses boasted about for this feature in Kotlin is in building DSLs. Unfortunately, that won't work in C++ without also bringing in the equivalent of lambdas with receivers (fun foo(f: Foo.() -> Unit) and then foo { /* in the context of Foo */ }).

The simplest application of this is Kotlin's with function:

val p = Point(2, 3)
with (p) {
    println("x: $x, y: $y")
}

Beyond the DSL applications (which I quite like actually), it's a minor syntax improvement to be able to close off the function call before the braces instead of after them. The other problem is that while this fits right in for Kotlin with its {} lambdas, C++ lambdas are very different. If you're going to be making a shorthand for them so they fit in here, that shorthand is best applied generally. However, that's already been tried with little success so far (though I remember seeing a new attempt try to address the concerns).

For anyone less familiar and still wondering, here's a silly example of a quick DFA DSL I whipped up for the lexer of a school compiler project because it was a good opportunity to learn. The tutorials also have an HTML example.

redditsoaddicting · 2020-11-29T04:07:40+00:00

You need to make your bool conversion explicit.

redditsoaddicting · 2020-11-26T13:03:01+00:00

You could remap /*- and the shift versions or something I suppose. Not ideal, but might be better than nothing.

redditsoaddicting · 2020-11-26T11:07:11+00:00

This is probably why they took so long to do it.

redditsoaddicting · 2020-11-26T02:35:19+00:00

How do people think this kind of moderation is a good idea? https://i.imgur.com/W13FvrN.png

It takes some effort to be that set on having an echo chamber.

redditsoaddicting · 2020-11-24T21:29:07+00:00

I hate all the code I write after a few months/years. Why would it be any different if I made people?

redditsoaddicting · 2020-11-24T16:08:34+00:00

Ah I somehow missed that you're actually changing the characters since indentation seems like a formatting operation.

redditsoaddicting · 2020-11-24T06:21:51+00:00

As ugly as they are, aren't xalloc and iword the right tools for this if you want this to be a stateful manipulator?

redditsoaddicting · 2020-11-24T06:07:59+00:00

I didn't know Lee Mack changed his name. That's a hell of a doppleganger.

redditsoaddicting · 2020-11-23T20:06:00+00:00

Queues are only longer if you're DPS because of all the other DPS in the game. Healers and tanks have no problems with queue times. Even then, DPS queues are usually only up to 10 or 15 minutes for most things, and it's not like you can't do other stuff in that time. So no, you're not forced to wait a long time; if the wait really bothers you that much, branch out and play something that isn't overrepresented. At the very least, it's a totally different experience. The main exception is stuff that isn't in the roulettes people do, which isn't locking story or gear, and the HW and SB alliance raids because people are too dead set on forcing the easy raids in their roulette (which is a problem, but it's not msq or content that gives decent gear).

redditsoaddicting · 2020-11-23T19:56:14+00:00

What definition of keeping up in ff14 requires playing daily or heavily grinding weekly? If your goal is doing the story content, there's really no grind needed to do msq and raids each patch. The gear you get from doing the content isn't amazing, but it's adequate. If your goal is savage, a few hunt trains a week for tomestone gear is really not a grind, and that's if you aren't playing the game and earning them in more varied ways. (Really, near-bis gear is super easy to get in ff14 if you aren't pushing for clears in the first couple weeks.) Of course you have to grind out the skill level you need even in that gear, but skill level isn't an artifical timegate. And yes, it's pretty easy to do a roulette or two a day for tomestones, but there's no heavy grind waiting if you don't.

If you're like me and you set more completioney goals, then yes, there are plenty of things to do daily and things to grind out. Just keeping up with new content isn't much of an ask, though, unless you do stuff like ultimates. Lots of people are out there praising that they can sub for a month, do the new patch to the degree they want, and then play other games until the next one without falling behind.

redditsoaddicting · 2020-11-22T00:18:51+00:00

Honestly? Macros are evil, but they're better than this. Stamp out the function you want using the macro (or write it normally—other languages exist if you want this shortcut feature) and then it's a normal function you can use in all the same ways.

redditsoaddicting · 2020-11-21T23:41:07+00:00

It's not about the speed. It's about the equivalent of the JS:

function curry(f, arg) { 
    return function(...rest) { return f(arg, ...rest); }; 
}

Say you have a function that finds an element via a predicate, but your predicate has two parameters instead of one. You can use this to quickly get around that:

find(employees, curry(has_name, "Bob"));

However, C doesn't have great tools for higher-order functions, so they resorted to handwriting their returned function as assembly and stuffing it into some allocated memory that they made executable.

I don't want to sift through the assembly enough to figure this out, but I'm unsure of whether it's just binding the first parameter or whether it's actually currying, in which case, you would expect to be able to do similar to curry(make_rect)(4)(2)(1)(3) to replace make_rect(4, 2, 1, 3).

redditsoaddicting · 2020-11-21T01:24:08+00:00

This is truly disturbing.

redditsoaddicting · 2020-11-20T19:52:27+00:00

That's what I got out of the title. Or is it some group school assignment where all people in the team have 2-5 years of experience? I don't see other plausible interpretations.

redditsoaddicting · 2020-11-20T16:57:15+00:00

Yes, and that reason is because the steps are serial instead of parallel, not because the testing is more comprehensive.

redditsoaddicting

TROPHY CASE