you really want infix notation? go do some APL

Not mentioning fixed point in an article about floating point alternatives is a sin. Unlike any of the alternatives listed here (yes, even floating point), if your computer can do integers, fixed-point comes practically builtin! it’s literally the same machine instruction plus one or two bitwise shifts.

Decimal floating point is probably the worst of every world. Without specialized hardware, implementing floating point is pretty hard in software, and comparatively slow. Since internally the decimals are stored in binary, a shift in the exponent means you have to recompute the mantissa as if you did multiplication or division, so you also lose the advantages of binary :)

Fractions are probably the most practical implementation for arbitrary precision as they are base-agnostic, and thus, free of repeating fractionals. The problem is that you need to do lots of gcd and lcm for addition. I have never done a full implementation, but I’d say libraries represent them internally as mixed numbers, integer part and less-than-one fractional part.

Symbolic computation is really hard. I hope you know your data structures and graph traversals!

Interval arithmetic is niche and I didn’t pay attention to the lecture on measure errors so I’m not very familiar, but wikipedia says binary operations between intervals is literally matching and min/maxxing so this one may have the second simplest software implementation.

For binary-coded decimal my guess is that decimal digits are stored as 4 bits each. Probably wasteful for any kind of arithmetic, so their use would mainly be conversions–after all, no matter how good binary is, people are used to decimal (which is not even that good of a base), and it’s the computer’s task to output that.

Perspective projection formulas are a walk in the park until you need to rotate things and compose rigid transformations, you better know how to build those quaternions and matrices ;)

c/fuckxavier

Page Up/Page Down gang

Reading this gave me a headache

So old school of you to play 1.5 instead of 1.6

Freeman’s mind is youtube gold. I can’t play half-life without imagining gordon being a sociopath asshole.

I mean, just because you implemented something in a low level lang, it doesn’t mean you’re gonna have the fastest implementation. Even in high level langs, there’s usually heavy optimization involved in things that are done all the time (e.g. web servers)

NTA. Your PS4, your rules.

A vibe programmer that built a palm-sized fusion reactor in a cave over the course of 3 months with a single companion? Perfectly respectable to me. And he probably made his own AI too :)

I’ve always imagined peak programming as building up from low level languages, putting on some layers of abstraction and automatization written by yourself, and end up writing some trivial commands to produce very interesting outputs… Who knows? Maybe throwing around some holograms and voice-commands asking for nonsense. It doesn’t get much more vibey than that.

Programming in vim and emacs does look like that lol.

It gets deeper. It’s also the same as the 0-k-vector, the 0-k-blade, the 0-multivector, the only number that is its own square besides 1, etc…

0! = 1 isn’t an exception.

Factorial is one of the solutions of the recurrence relationship f(x+1) = x * f(x). If one states that f(1) = 1, then it only follows from the recurrence that f(0) = 1 too, and in fact f(x) is undefined for negative integers, as it is with any function that has the property.

It would be more of an exception to say f(0) != 1, since it explicitly denies the rule, and instead would need some special case so that its defined in 0.

Multiplication order in current mathematics standards should happen the other way around when it’s in a non-commutative algebra.

The good thing about multiplication being commutative and associative is that you can think about it either way (e.g. 3x2 can be thought of as "add two three times). The “benefit” of carrying this idea to higher-order operations is that they become left-associative (meaning they can be evaluated from left to right), which is slightly more intuitive. For instance in lambda calculus, a sequence of church numerals n₁ n₂ … n_K mean n_K ^ n_K-1 ^ … ^ n₁ in traditional notation.

For example, we can’t write 2ω for the next transfinite ordinal because 2ω is just ω again on account of transfinite and backwards multiplication weirdness, and we have to write ω·2 or ω×2 instead like we’re back at primary school.

I’d say the deeper issue with ordinal arithmetic is that Knuth’s up-arrow notation with its recursive definition becomes useless to define ordinals bigger than ε₀, because something like ω^(ω^^ω) = ω^ε0 = ε₀. I don’t understand the exact notion deeply yet, but I suspect there’s some guilt in the fact that hyperoperations are fundamentally right-associative.

They are still real numbers. Specifically uncomputable, normal numbers. Which means their rational expansion contain every natural number.

Zero is the absence of a quantity, but it is still a number.

Or “we tricked rocks into thinking”

Can’t you tell it’s satire? They also said java is javascript

Read the post again lol